@qduc/term2 0.7.3 → 0.8.0

package/dist/tools/system/code-context.test.js

@@ -0,0 +1,646 @@
+import { it, expect } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { createCodeContextSearchToolDefinition, createReadCodeOutlineToolDefinition } from './code-context.js';
+async function withTempWorkspace(run) {
+    const originalCwd = process.cwd;
+    const rootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'term2-code-context-'));
+    const workspaceDir = path.join(rootDir, 'workspace');
+    await fs.mkdir(workspaceDir, { recursive: true });
+    process.cwd = () => workspaceDir;
+    try {
+        await run(workspaceDir);
+    }
+    finally {
+        process.cwd = originalCwd;
+        await fs.rm(rootDir, { recursive: true, force: true });
+    }
+}
+const readCodeOutlineToolDefinition = createReadCodeOutlineToolDefinition();
+const codeContextSearchToolDefinition = createCodeContextSearchToolDefinition();
+it.sequential('needsApproval: code context tools are read-only', async () => {
+    await withTempWorkspace(async () => {
+        expect(await readCodeOutlineToolDefinition.needsApproval({ path: 'src/example.ts' })).toBe(false);
+        expect(await codeContextSearchToolDefinition.needsApproval({ query_type: 'symbol', symbol: 'example' })).toBe(false);
+    });
+});
+it.sequential('schema: read_code_outline requires a path and rejects null', async () => {
+    await withTempWorkspace(async () => {
+        expect(readCodeOutlineToolDefinition.parameters.safeParse({ path: 'src/example.ts' }).success).toBe(true);
+        expect(readCodeOutlineToolDefinition.parameters.safeParse({}).success).toBe(false);
+        expect(readCodeOutlineToolDefinition.parameters.safeParse({ path: null }).success).toBe(false);
+    });
+});
+it.sequential('schema: code_context_search enforces query-type-specific fields and optional max_results', async () => {
+    await withTempWorkspace(async () => {
+        expect(codeContextSearchToolDefinition.parameters.safeParse({ query_type: 'related', path: 'src/example.ts' }).success).toBe(true);
+        expect(codeContextSearchToolDefinition.parameters.safeParse({ query_type: 'related' }).success).toBe(false);
+        expect(codeContextSearchToolDefinition.parameters.safeParse({ query_type: 'related', path: null }).success).toBe(false);
+        expect(codeContextSearchToolDefinition.parameters.safeParse({
+            query_type: 'related',
+            path: 'src/example.ts',
+            max_results: null,
+        }).success).toBe(false);
+        expect(codeContextSearchToolDefinition.parameters.safeParse({ query_type: 'symbol', symbol: 'buildThing' }).success).toBe(true);
+        expect(codeContextSearchToolDefinition.parameters.safeParse({ query_type: 'symbol' }).success).toBe(false);
+        expect(codeContextSearchToolDefinition.parameters.safeParse({ query_type: 'symbol', symbol: null }).success).toBe(false);
+        expect(codeContextSearchToolDefinition.parameters.safeParse({
+            query_type: 'symbol',
+            symbol: 'buildThing',
+            max_results: null,
+        }).success).toBe(false);
+    });
+});
+it.sequential('execute: read_code_outline summarizes a TS file without bodies', async () => {
+    await withTempWorkspace(async (dir) => {
+        const filePath = 'src/example.ts';
+        const absPath = path.join(dir, filePath);
+        await fs.mkdir(path.dirname(absPath), { recursive: true });
+        await fs.writeFile(absPath, [
+            "import fs from 'fs/promises';",
+            "import { join } from 'path';",
+            "const local = require('./local.js');",
+            "const lazy = () => import('./lazy.js');",
+            "export { helper } from './helper.js';",
+            'export const value = 1;',
+            'export function publicThing() {',
+            "  return 'should-not-appear';",
+            '}',
+            'class InternalThing {',
+            '  method() {',
+            "    return 'also-hidden';",
+            '  }',
+            '}',
+            'function localThing() {',
+            "  return 'hidden-body';",
+            '}',
+        ].join('\n'));
+        const result = await readCodeOutlineToolDefinition.execute({ path: filePath });
+        expect(result.includes('FILE src/example.ts')).toBe(true);
+        expect(result.includes('LANG typescript')).toBe(true);
+        expect(result.includes('IMPORTS')).toBe(true);
+        expect(result.includes('EXPORTS')).toBe(true);
+        expect(result.includes('DECLARATIONS')).toBe(true);
+        expect(result).toMatch(/fs\/promises/);
+        expect(result).toMatch(/path/);
+        expect(result).toMatch(/\.\/local\.js/);
+        expect(result).toMatch(/\.\/lazy\.js/);
+        expect(result).toMatch(/export const value line=\d+/);
+        expect(result).toMatch(/function publicThing line=\d+/);
+        expect(result).toMatch(/class InternalThing line=\d+/);
+        expect(result.includes('should-not-appear')).toBe(false);
+        expect(result.includes('also-hidden')).toBe(false);
+        expect(result.includes('hidden-body')).toBe(false);
+    });
+});
+it.sequential('execute: code_context_search related warns for unsupported target language', async () => {
+    await withTempWorkspace(async (dir) => {
+        const filePath = 'notes/outline.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.mkdir(path.dirname(absPath), { recursive: true });
+        await fs.writeFile(absPath, 'plain text only');
+        const result = await codeContextSearchToolDefinition.execute({
+            query_type: 'related',
+            path: filePath,
+        });
+        expect(result.startsWith('WARNING unsupported_language')).toBe(true);
+        expect(result.includes('QUERY related')).toBe(true);
+        expect(result.includes('NO_RESULTS')).toBe(true);
+    });
+});
+it.sequential('execute: read_code_outline returns unknown language with empty sections', async () => {
+    await withTempWorkspace(async (dir) => {
+        const filePath = 'notes/outline.txt';
+        const absPath = path.join(dir, filePath);
+        await fs.mkdir(path.dirname(absPath), { recursive: true });
+        await fs.writeFile(absPath, 'plain text only');
+        const result = await readCodeOutlineToolDefinition.execute({ path: filePath });
+        expect(result.includes('FILE notes/outline.txt')).toBe(true);
+        expect(result.includes('LANG unknown')).toBe(true);
+        expect((result.match(/\bEMPTY\b/g) ?? []).length).toBe(3);
+    });
+});
+it.sequential('execute: code_context_search related finds tests, importers, and barrel exports', async () => {
+    await withTempWorkspace(async (dir) => {
+        const files = [
+            ['src/foo.ts', ['export const foo = 1;', 'export function buildFoo() {', '  return foo;', '}'].join('\n')],
+            ['src/foo.test.ts', ["import { foo } from './foo.js';", "it('foo', () => {", '  void foo;', '});'].join('\n')],
+            ['src/index.ts', ["export * from './foo.js';"].join('\n')],
+            ['src/consumer.ts', ["import { foo } from './foo.js';", 'console.log(foo);'].join('\n')],
+        ];
+        for (const [filePath, content] of files) {
+            const absPath = path.join(dir, filePath);
+            await fs.mkdir(path.dirname(absPath), { recursive: true });
+            await fs.writeFile(absPath, content);
+        }
+        const result = await codeContextSearchToolDefinition.execute({
+            query_type: 'related',
+            path: 'src/foo.ts',
+            max_results: 10,
+        });
+        expect(result.includes('QUERY related')).toBe(true);
+        expect(result.includes('TARGET src/foo.ts')).toBe(true);
+        expect(result.includes('src/foo.test.ts')).toBe(true);
+        expect(result.includes('REL likely_test')).toBe(true);
+        expect(result.includes('src/index.ts')).toBe(true);
+        expect(result.includes('REL barrel_export')).toBe(true);
+        expect(result.includes('src/consumer.ts')).toBe(true);
+        expect(result.includes('REL imported_by_target')).toBe(true);
+    });
+});
+it.sequential('execute: code_context_search related honors max_results', async () => {
+    await withTempWorkspace(async (dir) => {
+        const files = [
+            'src/foo.ts',
+            'src/foo.test.ts',
+            'src/foo.spec.ts',
+            'src/index.ts',
+            'src/consumer.ts',
+            'src/another-consumer.ts',
+        ];
+        for (const filePath of files) {
+            const absPath = path.join(dir, filePath);
+            await fs.mkdir(path.dirname(absPath), { recursive: true });
+            await fs.writeFile(absPath, "import { foo } from './foo.js';\nvoid foo;\n");
+        }
+        const result = await codeContextSearchToolDefinition.execute({
+            query_type: 'related',
+            path: 'src/foo.ts',
+            max_results: 1,
+        });
+        const resultBlocks = result.split('\n\n').filter((part) => part.startsWith('src/'));
+        expect(resultBlocks.length <= 1).toBe(true);
+        expect(result.includes('src/foo.test.ts') || result.includes('src/foo.spec.ts')).toBe(true);
+    });
+});
+it.sequential('execute: code_context_search related detects multi-line named imports', async () => {
+    await withTempWorkspace(async (dir) => {
+        const files = [
+            ['src/foo.ts', 'export const foo = 1;\n'],
+            ['src/consumer.ts', ['import {', '  foo,', "} from './foo.js';", '', 'console.log(foo);'].join('\n')],
+        ];
+        for (const [filePath, content] of files) {
+            const absPath = path.join(dir, filePath);
+            await fs.mkdir(path.dirname(absPath), { recursive: true });
+            await fs.writeFile(absPath, content);
+        }
+        const result = await codeContextSearchToolDefinition.execute({
+            query_type: 'related',
+            path: 'src/foo.ts',
+        });
+        expect(result.includes('src/consumer.ts')).toBe(true);
+        expect(result.includes('REL imported_by_target')).toBe(true);
+    });
+});
+it.sequential('execute: code_context_search related does not flag same-named sibling modules', async () => {
+    await withTempWorkspace(async (dir) => {
+        const files = [
+            ['src/a/util.ts', 'export const util = 1;\n'],
+            ['src/a/consumer.ts', ["import { util } from './util.js';", 'void util;'].join('\n')],
+            // src/b/other.ts imports its OWN sibling ./util, unrelated to src/a/util.ts
+            ['src/b/util.ts', 'export const util = 2;\n'],
+            ['src/b/other.ts', ["import { util } from './util.js';", 'void util;'].join('\n')],
+        ];
+        for (const [filePath, content] of files) {
+            const absPath = path.join(dir, filePath);
+            await fs.mkdir(path.dirname(absPath), { recursive: true });
+            await fs.writeFile(absPath, content);
+        }
+        const result = await codeContextSearchToolDefinition.execute({
+            query_type: 'related',
+            path: 'src/a/util.ts',
+        });
+        expect(result.includes('src/a/consumer.ts')).toBe(true);
+        expect(result.includes('src/b/other.ts')).toBe(false);
+    });
+});
+const symbolCases = [
+    {
+        label: 'typescript',
+        filePath: 'src/ts-example.ts',
+        symbol: 'buildTsExample',
+        content: [
+            'export function buildTsExample() {',
+            "  return 'ts';",
+            '}',
+            'function hiddenTsExample() {',
+            "  return 'hidden';",
+            '}',
+        ].join('\n'),
+        expectedKind: 'function',
+        expectedExported: true,
+    },
+    {
+        label: 'javascript',
+        filePath: 'src/js-example.js',
+        symbol: 'buildJsExample',
+        content: ['export function buildJsExample() {', "  return 'js';", '}'].join('\n'),
+        expectedKind: 'function',
+        expectedExported: true,
+    },
+    {
+        label: 'python',
+        filePath: 'src/py-example.py',
+        symbol: 'build_python_example',
+        content: ['def build_python_example():', "    return 'py'"].join('\n'),
+        expectedKind: 'function',
+        expectedExported: false,
+    },
+    {
+        label: 'go',
+        filePath: 'src/go-example.go',
+        symbol: 'BuildGoExample',
+        content: ['package main', '', 'func BuildGoExample() {}'].join('\n'),
+        expectedKind: 'function',
+        expectedExported: true,
+    },
+    {
+        label: 'rust',
+        filePath: 'src/rs-example.rs',
+        symbol: 'build_rust_example',
+        content: ['pub fn build_rust_example() {}'].join('\n'),
+        expectedKind: 'function',
+        expectedExported: true,
+    },
+];
+for (const symbolCase of symbolCases) {
+    it.sequential(`execute: code_context_search symbol finds ${symbolCase.label} declarations`, async () => {
+        await withTempWorkspace(async (dir) => {
+            const absPath = path.join(dir, symbolCase.filePath);
+            await fs.mkdir(path.dirname(absPath), { recursive: true });
+            await fs.writeFile(absPath, symbolCase.content);
+            const result = await codeContextSearchToolDefinition.execute({
+                query_type: 'symbol',
+                symbol: symbolCase.symbol,
+            });
+            expect(result.includes(`QUERY symbol`)).toBe(true);
+            expect(result.includes(`SYMBOL ${symbolCase.symbol}`)).toBe(true);
+            expect(result.includes(symbolCase.filePath)).toBe(true);
+            expect(result).toMatch(new RegExp(`${symbolCase.filePath}:\\d+ ${symbolCase.expectedKind} ${symbolCase.symbol}`));
+            if (symbolCase.expectedExported) {
+                expect(result.includes('exported')).toBe(true);
+            }
+            else {
+                expect(result.includes('exported')).toBe(false);
+            }
+        });
+    });
+}
+it.sequential('execute: code_context_search rejects paths outside the workspace', async () => {
+    await withTempWorkspace(async () => {
+        const outlineResult = await readCodeOutlineToolDefinition.execute({ path: '/etc/outside.ts' });
+        const relatedResult = await codeContextSearchToolDefinition.execute({
+            query_type: 'related',
+            path: '/etc/outside.ts',
+        });
+        expect(outlineResult.includes('outside workspace')).toBe(true);
+        expect(relatedResult.includes('outside workspace')).toBe(true);
+    });
+});
+it.sequential('execute: code_context_search rejects unsafe symbol names', async () => {
+    await withTempWorkspace(async () => {
+        const result = await codeContextSearchToolDefinition.execute({
+            query_type: 'symbol',
+            symbol: 'build.*',
+        });
+        expect(result.startsWith('Error')).toBe(true);
+        expect(result.toLowerCase().includes('identifier')).toBe(true);
+    });
+});
+it.sequential('outline: inline type imports do not leak the type keyword into names', async () => {
+    await withTempWorkspace(async (dir) => {
+        const filePath = 'src/inline-type.ts';
+        const absPath = path.join(dir, filePath);
+        await fs.mkdir(path.dirname(absPath), { recursive: true });
+        await fs.writeFile(absPath, [
+            "import { type Foo, Bar } from './types';",
+            "import { type Baz as Renamed, Qux } from './other';",
+            'export const x = 1;',
+        ].join('\n'));
+        const result = await readCodeOutlineToolDefinition.execute({ path: filePath });
+        // 'type Foo' should not appear — only 'Foo'
+        expect(result.includes('type Foo')).toBe(false);
+        expect(result.includes('Foo')).toBe(true);
+        expect(result.includes('Bar')).toBe(true);
+        // 'type Baz' should not appear — only 'Renamed' (the alias)
+        expect(result.includes('type Baz')).toBe(false);
+        expect(result.includes('Renamed')).toBe(true);
+        expect(result.includes('Qux')).toBe(true);
+    });
+});
+it.sequential('outline: async functions retain async in declarations', async () => {
+    await withTempWorkspace(async (dir) => {
+        const filePath = 'src/async-fn.ts';
+        const absPath = path.join(dir, filePath);
+        await fs.mkdir(path.dirname(absPath), { recursive: true });
+        await fs.writeFile(absPath, [
+            'export async function fetchData() {',
+            "  return 'data';",
+            '}',
+            'async function internalFetch() {',
+            "  return 'internal';",
+            '}',
+            'function syncThing() {',
+            "  return 'sync';",
+            '}',
+        ].join('\n'));
+        const result = await readCodeOutlineToolDefinition.execute({ path: filePath });
+        // Async functions should show 'async function', not just 'function'
+        expect(result.includes('async function fetchData')).toBe(true);
+        expect(result.includes('async function internalFetch')).toBe(true);
+        // Sync function stays as 'function'
+        expect(result.includes('function syncThing')).toBe(true);
+    });
+});
+it.sequential('outline: JSON files extract top-level keys as declarations', async () => {
+    await withTempWorkspace(async (dir) => {
+        const filePath = 'package.json';
+        const absPath = path.join(dir, filePath);
+        await fs.writeFile(absPath, JSON.stringify({ name: 'test', version: '1.0.0', scripts: { build: 'tsc' } }));
+        const result = await readCodeOutlineToolDefinition.execute({ path: filePath });
+        expect(result.includes('LANG json')).toBe(true);
+        expect(result.includes('name')).toBe(true);
+        expect(result.includes('version')).toBe(true);
+        expect(result.includes('scripts')).toBe(true);
+    });
+});
+it.sequential('outline: Python files extract imports and declarations', async () => {
+    await withTempWorkspace(async (dir) => {
+        const filePath = 'src/example.py';
+        const absPath = path.join(dir, filePath);
+        await fs.mkdir(path.dirname(absPath), { recursive: true });
+        await fs.writeFile(absPath, [
+            'import os',
+            'from sys import argv',
+            'from collections import (',
+            '    defaultdict,',
+            '    OrderedDict as OD',
+            ')',
+            '# some comment def hidden',
+            'class MyClass:',
+            '    def nested_method(self):',
+            '        pass',
+            'def my_func():',
+            '    pass',
+            'async def my_async_func():',
+            '    pass',
+        ].join('\n'));
+        const result = await readCodeOutlineToolDefinition.execute({ path: filePath });
+        expect(result.includes('FILE src/example.py')).toBe(true);
+        expect(result.includes('LANG python')).toBe(true);
+        expect(result.includes('IMPORTS')).toBe(true);
+        expect(result.includes('DECLARATIONS')).toBe(true);
+        expect(result).toMatch(/os: os/);
+        expect(result).toMatch(/sys: argv/);
+        expect(result).toMatch(/collections: defaultdict OD/);
+        expect(result).toMatch(/class MyClass/);
+        expect(result).toMatch(/function my_func/);
+        expect(result).toMatch(/async function my_async_func/);
+        expect(result.includes('nested_method')).toBe(false); // nested method is indented
+    });
+});
+it.sequential('outline: Go files extract imports and declarations with visibility', async () => {
+    await withTempWorkspace(async (dir) => {
+        const filePath = 'src/example.go';
+        const absPath = path.join(dir, filePath);
+        await fs.mkdir(path.dirname(absPath), { recursive: true });
+        await fs.writeFile(absPath, [
+            'package main',
+            'import "fmt"',
+            'import (',
+            '    "os"',
+            '    "path/filepath"',
+            '    alias "net/http"',
+            ')',
+            'type MyStruct struct{}',
+            'type MyInterface interface{}',
+            'const MyConst = 42',
+            'var MyVar = "hello"',
+            'const (',
+            '    Const1 = 1',
+            '    const2 = 2',
+            ')',
+            'var (',
+            '    Var1 = 1',
+            '    var2 = 2',
+            ')',
+            'func ExportedFunc() {}',
+            'func privateFunc() {}',
+            'func (m *MyStruct) Method() {}',
+        ].join('\n'));
+        const result = await readCodeOutlineToolDefinition.execute({ path: filePath });
+        expect(result.includes('FILE src/example.go')).toBe(true);
+        expect(result.includes('LANG go')).toBe(true);
+        expect(result.includes('IMPORTS')).toBe(true);
+        expect(result.includes('EXPORTS')).toBe(true);
+        expect(result.includes('DECLARATIONS')).toBe(true);
+        expect(result).toMatch(/fmt: side-effect/);
+        expect(result).toMatch(/os: side-effect/);
+        expect(result).toMatch(/path\/filepath: side-effect/);
+        expect(result).toMatch(/net\/http: alias/);
+        expect(result).toMatch(/type MyStruct line=\d+ exported/);
+        expect(result).toMatch(/interface MyInterface line=\d+ exported/);
+        expect(result).toMatch(/const MyConst line=\d+ exported/);
+        expect(result).toMatch(/var MyVar line=\d+ exported/);
+        expect(result).toMatch(/const Const1 line=\d+ exported/);
+        expect(result).toMatch(/const const2 line=\d+\s*$/m); // not exported
+        expect(result).toMatch(/var Var1 line=\d+ exported/);
+        expect(result).toMatch(/var var2 line=\d+\s*$/m); // not exported
+        expect(result).toMatch(/function ExportedFunc line=\d+ exported/);
+        expect(result).toMatch(/function privateFunc line=\d+\s*$/m); // not exported
+        expect(result).toMatch(/method Method line=\d+ exported/);
+        // exports
+        expect(result).toMatch(/export type MyStruct line=\d+/);
+        expect(result).toMatch(/export interface MyInterface line=\d+/);
+        expect(result).toMatch(/export const MyConst line=\d+/);
+        expect(result).toMatch(/export var MyVar line=\d+/);
+        expect(result).toMatch(/export const Const1 line=\d+/);
+        expect(result).toMatch(/export var Var1 line=\d+/);
+        expect(result).toMatch(/export function ExportedFunc line=\d+/);
+        expect(result).toMatch(/export method Method line=\d+/);
+        expect(result.includes('const2 line=') && result.includes('export const const2')).toBe(false);
+    });
+});
+it.sequential('outline: Rust files extract imports and declarations with visibility', async () => {
+    await withTempWorkspace(async (dir) => {
+        const filePath = 'src/example.rs';
+        const absPath = path.join(dir, filePath);
+        await fs.mkdir(path.dirname(absPath), { recursive: true });
+        await fs.writeFile(absPath, [
+            'use std::collections::HashMap;',
+            'pub use std::io::{self, Write};',
+            'use std::fs as my_fs;',
+            'pub struct PublicStruct;',
+            'struct PrivateStruct;',
+            'pub enum PublicEnum {}',
+            'pub trait PublicTrait {}',
+            'pub type PublicType = i32;',
+            'pub const MY_CONST: i32 = 123;',
+            'pub fn public_fn() {}',
+            'fn private_fn() {}',
+        ].join('\n'));
+        const result = await readCodeOutlineToolDefinition.execute({ path: filePath });
+        expect(result.includes('FILE src/example.rs')).toBe(true);
+        expect(result.includes('LANG rust')).toBe(true);
+        expect(result.includes('IMPORTS')).toBe(true);
+        expect(result.includes('EXPORTS')).toBe(true);
+        expect(result.includes('DECLARATIONS')).toBe(true);
+        expect(result).toMatch(/std::collections: HashMap/);
+        expect(result).toMatch(/std::io: self Write/);
+        expect(result).toMatch(/std: my_fs/);
+        expect(result).toMatch(/type PublicStruct line=\d+ exported/);
+        expect(result).toMatch(/type PrivateStruct line=\d+\s*$/m); // not exported
+        expect(result).toMatch(/enum PublicEnum line=\d+ exported/);
+        expect(result).toMatch(/interface PublicTrait line=\d+ exported/);
+        expect(result).toMatch(/type PublicType line=\d+ exported/);
+        expect(result).toMatch(/const MY_CONST line=\d+ exported/);
+        expect(result).toMatch(/function public_fn line=\d+ exported/);
+        expect(result).toMatch(/function private_fn line=\d+\s*$/m); // not exported
+        // exports
+        expect(result).toMatch(/export type PublicStruct line=\d+/);
+        expect(result).toMatch(/export enum PublicEnum line=\d+/);
+        expect(result).toMatch(/export interface PublicTrait line=\d+/);
+        expect(result).toMatch(/export type PublicType line=\d+/);
+        expect(result).toMatch(/export const MY_CONST line=\d+/);
+        expect(result).toMatch(/export function public_fn line=\d+/);
+    });
+});
+it.sequential('outline: Java files extract imports and declarations', async () => {
+    await withTempWorkspace(async (dir) => {
+        const filePath = 'src/Example.java';
+        const absPath = path.join(dir, filePath);
+        await fs.mkdir(path.dirname(absPath), { recursive: true });
+        await fs.writeFile(absPath, [
+            'package com.example;',
+            'import java.util.List;',
+            'import static org.junit.Assert.assertEquals;',
+            'public class Example {',
+            '    public Example() {}',
+            '    public void doSomething() {}',
+            '    private String calculate() { return "java"; }',
+            '}',
+        ].join('\n'));
+        const result = await readCodeOutlineToolDefinition.execute({ path: filePath });
+        expect(result.includes('FILE src/Example.java')).toBe(true);
+        expect(result.includes('LANG java')).toBe(true);
+        expect(result).toMatch(/java.util.List: List line=2/);
+        expect(result).toMatch(/org.junit.Assert.assertEquals: assertEquals line=3/);
+        expect(result).toMatch(/class Example line=4 exported/);
+        expect(result).toMatch(/method Example line=5 exported/);
+        expect(result).toMatch(/method doSomething line=6 exported/);
+        expect(result).toMatch(/method calculate line=7/);
+        expect(result.includes('method calculate line=7 exported')).toBe(false);
+    });
+});
+it.sequential('outline: C# files extract imports and declarations', async () => {
+    await withTempWorkspace(async (dir) => {
+        const filePath = 'src/Example.cs';
+        const absPath = path.join(dir, filePath);
+        await fs.mkdir(path.dirname(absPath), { recursive: true });
+        await fs.writeFile(absPath, [
+            'using System;',
+            'using System.Collections.Generic;',
+            'namespace App {',
+            '    public class Example {',
+            '        public Example() {}',
+            '        public void DoSomething() {}',
+            '        private string GetName() { return "cs"; }',
+            '    }',
+            '    public struct MyStruct {}',
+            '}',
+        ].join('\n'));
+        const result = await readCodeOutlineToolDefinition.execute({ path: filePath });
+        expect(result.includes('FILE src/Example.cs')).toBe(true);
+        expect(result.includes('LANG csharp')).toBe(true);
+        expect(result).toMatch(/System: System line=1/);
+        expect(result).toMatch(/System.Collections.Generic: Generic line=2/);
+        expect(result).toMatch(/class Example line=4 exported/);
+        expect(result).toMatch(/method Example line=5 exported/);
+        expect(result).toMatch(/method DoSomething line=6 exported/);
+        expect(result).toMatch(/method GetName line=7/);
+        expect(result).toMatch(/class MyStruct line=9 exported/);
+    });
+});
+it.sequential('outline: C/C++ files extract imports and declarations', async () => {
+    await withTempWorkspace(async (dir) => {
+        const filePath = 'src/example.cpp';
+        const absPath = path.join(dir, filePath);
+        await fs.mkdir(path.dirname(absPath), { recursive: true });
+        await fs.writeFile(absPath, [
+            '#include <vector>',
+            '#include "helper.h"',
+            'struct Point {',
+            '    int x;',
+            '};',
+            'class Calculator {',
+            'public:',
+            '    int add(int a, int b) { return a + b; }',
+            '};',
+            'int main() {',
+            '    return 0;',
+            '}',
+        ].join('\n'));
+        const result = await readCodeOutlineToolDefinition.execute({ path: filePath });
+        expect(result.includes('FILE src/example.cpp')).toBe(true);
+        expect(result.includes('LANG cpp')).toBe(true);
+        expect(result).toMatch(/<vector>: side-effect line=1/);
+        expect(result).toMatch(/\.\/helper.h: side-effect line=2/);
+        expect(result).toMatch(/class Point line=3 exported/);
+        expect(result).toMatch(/class Calculator line=6 exported/);
+        expect(result).toMatch(/method add line=8 exported/);
+        expect(result).toMatch(/function main line=10 exported/);
+    });
+});
+it.sequential('outline: Ruby files extract imports and declarations', async () => {
+    await withTempWorkspace(async (dir) => {
+        const filePath = 'src/example.rb';
+        const absPath = path.join(dir, filePath);
+        await fs.mkdir(path.dirname(absPath), { recursive: true });
+        await fs.writeFile(absPath, [
+            "require 'json'",
+            "require_relative 'helper'",
+            'module MyModule',
+            '    class MyClass',
+            '    end',
+            'end',
+            'def top_level_method',
+            'end',
+        ].join('\n'));
+        const result = await readCodeOutlineToolDefinition.execute({ path: filePath });
+        expect(result.includes('FILE src/example.rb')).toBe(true);
+        expect(result.includes('LANG ruby')).toBe(true);
+        expect(result).toMatch(/json: side-effect line=1/);
+        expect(result).toMatch(/helper: side-effect line=2/);
+        expect(result).toMatch(/class MyModule line=3 exported/);
+        expect(result).toMatch(/class MyClass line=4 exported/);
+        expect(result).toMatch(/function top_level_method line=7 exported/);
+    });
+});
+it.sequential('outline: PHP files extract imports and declarations', async () => {
+    await withTempWorkspace(async (dir) => {
+        const filePath = 'src/example.php';
+        const absPath = path.join(dir, filePath);
+        await fs.mkdir(path.dirname(absPath), { recursive: true });
+        await fs.writeFile(absPath, [
+            '<?php',
+            'namespace App\\Core;',
+            'use App\\Utils\\Helper;',
+            'class Controller {',
+            '    public function index() {}',
+            '}',
+            'interface Service {}',
+            'function global_func() {}',
+        ].join('\n'));
+        const result = await readCodeOutlineToolDefinition.execute({ path: filePath });
+        expect(result.includes('FILE src/example.php')).toBe(true);
+        expect(result.includes('LANG php')).toBe(true);
+        expect(result).toMatch(/App\\Core: side-effect line=2/);
+        expect(result).toMatch(/App\\Utils\\Helper: side-effect line=3/);
+        expect(result).toMatch(/class Controller line=4 exported/);
+        expect(result).toMatch(/function index line=5 exported/);
+        expect(result).toMatch(/interface Service line=7 exported/);
+        expect(result).toMatch(/function global_func line=8 exported/);
+    });
+});
+//# sourceMappingURL=code-context.test.js.map