connectai/tests/localPathPreflight.test.ts

import * as fs from 'fs';
import * as os from 'os';
import * as path from 'path';
import { AgentExecutor } from '../src/agent';

function stateStore() {
    const store = new Map<string, any>();
    return {
        get: (key: string) => store.get(key),
        update: async (key: string, value: any) => {
            store.set(key, value);
        }
    };
}

describe('local project path preflight', () => {
    let root: string;

    beforeEach(() => {
        root = fs.mkdtempSync(path.join(os.tmpdir(), 'g1-local-preflight-'));
        fs.mkdirSync(path.join(root, 'src', 'features', 'game', 'systems'), { recursive: true });
        fs.writeFileSync(path.join(root, 'package.json'), '{"scripts":{"dev":"vite"}}', 'utf8');
        fs.writeFileSync(path.join(root, 'src', 'features', 'game', 'systems', 'CombatSystem.ts'), 'export class CombatSystem {}', 'utf8');
    });

    afterEach(() => {
        fs.rmSync(root, { recursive: true, force: true });
    });

    it('previews deep source files instead of treating a project folder as empty', () => {
        const context: any = {
            globalStorageUri: { fsPath: path.join(root, '.storage') },
            workspaceState: stateStore(),
            globalState: stateStore()
        };
        const agent = new AgentExecutor(context) as any;

        const inspected = agent.inspectLocalProjectPath(root, root);

        expect(inspected).toContain('Access: succeeded');
        expect(inspected).toContain('Priority file previews');
        expect(inspected).toContain('package.json');
        expect(inspected).toContain('src/features/game/systems/CombatSystem.ts');
        expect(inspected).toContain('export class CombatSystem');
    });

    it('removes upload requests when local project access already succeeded', () => {
        const context: any = {
            globalStorageUri: { fsPath: path.join(root, '.storage') },
            workspaceState: stateStore(),
            globalState: stateStore()
        };
        const agent = new AgentExecutor(context) as any;
        const answer = '코드를 업로드해 주시면 검토하겠습니다.';
        const fixed = agent.enforceLocalPathReviewAnswer(answer, 'Access: succeeded\nPriority file previews:\n### package.json');

        expect(fixed).toContain('제공된 로컬 프로젝트 경로에는 접근할 수 있고');
        expect(fixed).not.toContain('코드를 업로드해 주시면');
    });

    it('treats project knowledge creation requests with local paths as inspectable work', () => {
        const context: any = {
            globalStorageUri: { fsPath: path.join(root, '.storage') },
            workspaceState: stateStore(),
            globalState: stateStore()
        };
        const agent = new AgentExecutor(context) as any;
        const prompt = '그러면 지금 /Volumes/Data/project/Antigravity/ConnectAI 이 프로젝트에 대한 지식을 만들면 되는거 아니야?';

        expect(agent.shouldPreflightLocalProjectPath(prompt)).toBe(true);
    });

    it('treats architecture opinion requests with local paths as inspectable work', () => {
        const context: any = {
            globalStorageUri: { fsPath: path.join(root, '.storage') },
            workspaceState: stateStore(),
            globalState: stateStore()
        };
        const agent = new AgentExecutor(context) as any;
        const prompt = '프로젝트 경로는 /Volumes/Data/project/Antigravity/ConnectAI 이야. 그럼 이 프로젝트에 대한 설계, 아키텍처는 어떤거 같아?';

        expect(agent.shouldPreflightLocalProjectPath(prompt)).toBe(true);
        expect(agent.isThinkingPartnerRequest(prompt)).toBe(true);
    });

    it('adds concrete Astra mode architecture context for Guard and MA design questions', () => {
        const context: any = {
            globalStorageUri: { fsPath: path.join(root, '.storage') },
            workspaceState: stateStore(),
            globalState: stateStore()
        };
        const agent = new AgentExecutor(context) as any;
        const prompt = '지금 우리는 guard 모드가 있고 MA 모드가 있는데 굳이 이렇게 모드를 분리해서 사용하는게 좋을까?';

        expect(agent.isAstraModeArchitectureQuestion(prompt)).toBe(true);
        const modeContext = agent.buildAstraModeArchitectureContext(prompt);
        expect(modeContext).toContain('Confirmed implementation facts');
        expect(modeContext).toContain('Guard should be an always-on policy/context layer');
        expect(modeContext).toContain('MA should be an optional execution strategy');
        expect(modeContext).toContain('richer context assembly');
    });

    it('keeps Guard and MA out of the visible sidebar controls', () => {
        const sidebarSource = fs.readFileSync(path.join(__dirname, '..', 'src', 'sidebarProvider.ts'), 'utf8');

        expect(sidebarSource).not.toContain('id="designerGuardBtn"');
        expect(sidebarSource).not.toContain('id="multiAgentBtn"');
    });

    it('routes multi-agent automatically for report-style tasks but not local project preflight', () => {
        const context: any = {
            globalStorageUri: { fsPath: path.join(root, '.storage') },
            workspaceState: stateStore(),
            globalState: stateStore()
        };
        const agent = new AgentExecutor(context) as any;

        expect(agent.shouldUseMultiAgentWorkflow('시장 조사 기반으로 긴 보고서를 작성해줘', false)).toBe(true);
        expect(agent.shouldUseMultiAgentWorkflow('프로젝트 경로는 /Volumes/Data/project/Antigravity/ConnectAI 이야. 아키텍처 봐줘', false)).toBe(false);
        expect(agent.shouldUseMultiAgentWorkflow('guard 모드와 MA 모드를 분리하는게 좋을까?', true)).toBe(false);
    });

    it('removes file-structure requests when knowledge creation path access already succeeded', () => {
        const context: any = {
            globalStorageUri: { fsPath: path.join(root, '.storage') },
            workspaceState: stateStore(),
            globalState: stateStore()
        };
        const agent = new AgentExecutor(context) as any;
        const answer = '프로젝트에 대한 지식을 만들고 싶다면, 먼저 해당 프로젝트의 핵심 파일이나 구조를 저에게 제공해 주셔야 합니다. 실제 구현 근거 없이는 유용한 지식을 만들 수 없습니다.';
        const fixed = agent.enforceLocalPathReviewAnswer(answer, 'Access: succeeded\nPriority file previews:\n### package.json');

        expect(fixed).toContain('프로젝트 지식을 만들 수 있습니다');
        expect(fixed).not.toContain('핵심 파일이나 구조를 저에게 제공');
        expect(fixed).not.toContain('실제 구현 근거 없이는');
    });

    it('replaces blocking scope questions for local project knowledge creation', () => {
        const context: any = {
            globalStorageUri: { fsPath: path.join(root, '.storage') },
            workspaceState: stateStore(),
            globalState: stateStore()
        };
        const agent = new AgentExecutor(context) as any;
        const answer = '## 블로킹 질문\n1. 어떤 기능 영역을 가장 먼저 분석하고 싶으신가요? (Question reason: 범위 조정)';
        const localPathContext = [
            'Path: /Volumes/Data/project/Antigravity/ConnectAI',
            'Access: succeeded',
            'Type: directory',
            'Scanned tree:',
            'src/',
            'src/agent.ts',
            'Priority file previews:',
            'File: package.json',
            '{"name":"g1nation"}',
            'File: src/agent.ts',
            'export class AgentExecutor {}'
        ].join('\n');

        expect(agent.isBlockingProjectKnowledgeAnswer(answer)).toBe(true);
        const fallback = agent.buildProjectKnowledgeFallbackAnswer(localPathContext);
        expect(fallback).toContain('추가 질문으로 멈출 필요 없이');
        expect(fallback).toContain('Astra Project Knowledge Overview');
        expect(fallback).not.toContain('어떤 기능 영역을 가장 먼저');
    });

    it('treats no-record-created answers as incomplete project knowledge creation', () => {
        const context: any = {
            globalStorageUri: { fsPath: path.join(root, '.storage') },
            workspaceState: stateStore(),
            globalState: stateStore()
        };
        const agent = new AgentExecutor(context) as any;
        const answer = 'Record Path Check: 요청하신 지식 생성 작업은 파일 목록 검토를 통해 완료되었으며, 별도의 파일 기록이 생성되지 않았습니다.';

        expect(agent.isBlockingProjectKnowledgeAnswer(answer)).toBe(true);
    });

    it('extracts only preview file markers, not markdown headings inside previews', () => {
        const context: any = {
            globalStorageUri: { fsPath: path.join(root, '.storage') },
            workspaceState: stateStore(),
            globalState: stateStore()
        };
        const agent = new AgentExecutor(context) as any;
        const localPathContext = [
            'Priority file previews:',
            'File: README.md',
            '### 1. 벡터화된 고성능 추론 엔진',
            'File: src/agent.ts',
            'export class AgentExecutor {}'
        ].join('\n');

        expect(agent.extractPriorityPreviewFiles(localPathContext)).toEqual(['README.md', 'src/agent.ts']);
    });

    it('writes a project knowledge record for accessible local project context', () => {
        const context: any = {
            globalStorageUri: { fsPath: path.join(root, '.storage') },
            workspaceState: stateStore(),
            globalState: stateStore()
        };
        const agent = new AgentExecutor(context) as any;
        const localPathContext = [
            `Path: ${root}`,
            'Access: succeeded',
            'Type: directory',
            'Scanned tree:',
            'package.json',
            'src/',
            'Priority file previews:',
            'File: package.json',
            '{"name":"g1nation"}',
            'File: src/features/game/systems/CombatSystem.ts',
            'export class CombatSystem {}'
        ].join('\n');

        const record = agent.writeProjectKnowledgeRecord(localPathContext);

        expect(record?.filePath).toBeTruthy();
        expect(fs.existsSync(record.filePath)).toBe(true);
        const content = fs.readFileSync(record.filePath, 'utf8');
        expect(content).toContain('Project Knowledge Overview');
        expect(content).toContain('package.json');
        expect(content).toContain('src/features/game/systems/CombatSystem.ts');
    });

    it('uses the latest project knowledge record for architecture follow-up questions without a path', () => {
        const context: any = {
            globalStorageUri: { fsPath: path.join(root, '.storage') },
            workspaceState: stateStore(),
            globalState: stateStore()
        };
        const agent = new AgentExecutor(context) as any;
        const recordDir = path.join(root, 'docs', 'records', path.basename(root), 'development');
        fs.mkdirSync(recordDir, { recursive: true });
        const recordPath = path.join(recordDir, '2026-05-02_project_knowledge_overview.md');
        fs.writeFileSync(
            recordPath,
            [
                '# Project Knowledge Overview',
                '',
                '## Confirmed Structure',
                '- `src/agent.ts`: 에이전트 실행 흐름의 중심.',
                '- `src/sidebarProvider.ts`: Webview UI를 담당.'
            ].join('\n'),
            'utf8'
        );

        const followup = agent.buildRecentProjectKnowledgeContext('이젠 아키텍처에 대한 조사도 해주면 좋을 것 같아.', root);

        expect(followup).toContain('[RECENT LOCAL PROJECT KNOWLEDGE]');
        expect(followup).toContain(recordPath);
        expect(followup).toContain('src/agent.ts');
        expect(followup).toContain('recently generated project knowledge record');
    });

    it('removes old Second Brain trace details from assistant history before model requests', () => {
        const context: any = {
            globalStorageUri: { fsPath: path.join(root, '.storage') },
            workspaceState: stateStore(),
            globalState: stateStore()
        };
        const agent = new AgentExecutor(context) as any;
        const history = [
            { role: 'user', content: 'ConnectAI 지식 만들어줘' },
            {
                role: 'assistant',
                content: [
                    '## 간단 요약',
                    'ConnectAI 프로젝트 지식을 만들었습니다.',
                    '<details>',
                    '<summary>2nd Brain Trace: 사용함</summary>',
                    'Project_Logs/2026-04-25-Datacollector_Fix.md',
                    '## Second Brain Debug JSON',
                    '{"path":"Datacollector"}',
                    '</details>'
                ].join('\n')
            }
        ];

        const requestHistory = agent.buildRequestHistory(history);

        expect(requestHistory[1].content).toContain('ConnectAI 프로젝트 지식을 만들었습니다');
        expect(requestHistory[1].content).not.toContain('Datacollector');
        expect(requestHistory[1].content).not.toContain('2nd Brain Trace');
    });

    it('adds visible evidence when answering from recent project knowledge context', () => {
        const context: any = {
            globalStorageUri: { fsPath: path.join(root, '.storage') },
            workspaceState: stateStore(),
            globalState: stateStore()
        };
        const agent = new AgentExecutor(context) as any;
        const recordPath = '/Volumes/Data/project/Antigravity/ConnectAI/docs/records/ConnectAI/development/2026-05-02_connectai_project_knowledge_overview.md';
        const recentContext = [
            '[RECENT LOCAL PROJECT KNOWLEDGE]',
            `Use this recently generated project knowledge record as project evidence: ${recordPath}`,
            '',
            '# Astra Project Knowledge Overview',
            '',
            '## Evidence Files',
            '- `package.json`',
            '- `src/agent.ts`',
            '- `src/sidebarProvider.ts`'
        ].join('\n');
        const answer = '## 간단 요약\nConnectAI 아키텍처는 실행 흐름 분리를 중심으로 구성됩니다.';

        const fixed = agent.ensureRecentProjectKnowledgeEvidence(answer, recentContext);

        expect(fixed).toContain('## 근거');
        expect(fixed).toContain(recordPath);
        expect(fixed).toContain('`src/agent.ts`');
        expect(fixed).toContain('최근 생성된 프로젝트 지식 기록');
    });

    it('adds visible evidence when answering from an explicit local project path', () => {
        const context: any = {
            globalStorageUri: { fsPath: path.join(root, '.storage') },
            workspaceState: stateStore(),
            globalState: stateStore()
        };
        const agent = new AgentExecutor(context) as any;
        const localPathContext = [
            'Path: /Volumes/Data/project/Antigravity/ConnectAI',
            'Access: succeeded',
            'Type: directory',
            'Scanned tree:',
            'package.json',
            'src/agent.ts',
            'Priority file previews:',
            'File: package.json',
            '```json',
            '{"name":"connectai"}',
            '```',
            'File: src/agent.ts',
            '```ts',
            'export class AgentExecutor {}',
            '```'
        ].join('\n');
        const answer = '## 간단 요약\nConnectAI 아키텍처는 실행 흐름 분리를 중심으로 구성됩니다.';

        const fixed = agent.ensureLocalProjectPathEvidence(answer, localPathContext);

        expect(fixed).toContain('## 근거');
        expect(fixed).toContain('/Volumes/Data/project/Antigravity/ConnectAI');
        expect(fixed).toContain('`package.json`');
        expect(fixed).toContain('`src/agent.ts`');
        expect(fixed).toContain('로컬 프로젝트 경로');
    });

    it('builds a Jarvis project brief for architecture thinking-partner questions', () => {
        const context: any = {
            globalStorageUri: { fsPath: path.join(root, '.storage') },
            workspaceState: stateStore(),
            globalState: stateStore()
        };
        const agent = new AgentExecutor(context) as any;
        const localPathContext = [
            'Path: /Volumes/Data/project/Antigravity/ConnectAI',
            'Access: succeeded',
            'Type: directory',
            'Scanned tree:',
            'package.json',
            'src/agent.ts',
            'src/features/secondBrainTrace.ts',
            'Priority file previews:',
            'File: package.json',
            '{"name":"connectai"}',
            'File: src/agent.ts',
            'export class AgentExecutor {}'
        ].join('\n');

        const brief = agent.buildJarvisProjectBriefContext(
            '그럼 이 프로젝트에 대한 설계, 아키텍처는 어떤거 같아?',
            localPathContext,
            ''
        );

        expect(brief).toContain('[JARVIS PROJECT BRIEF]');
        expect(brief).toContain('/Volumes/Data/project/Antigravity/ConnectAI');
        expect(brief).toContain('src/agent.ts');
        expect(brief).toContain('Thinking partner response contract');
        expect(brief).toContain('direct verdict');
        expect(brief).toContain('decision fork');
    });
});