@dotcontext/cli 0.8.2 → 0.9.0

package/dist/services/harness/contextTools.js

@@ -0,0 +1,990 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_NAMES = exports.getCodebaseMapTool = exports.fillScaffoldingTool = exports.fillSingleFileTool = exports.listFilesToFillTool = exports.scaffoldPlanTool = exports.initializeContextTool = exports.checkScaffoldingTool = exports.searchCodeTool = exports.getFileStructureTool = exports.analyzeSymbolsTool = exports.listFilesTool = exports.readFileTool = void 0;
+exports.getOrBuildContext = getOrBuildContext;
+exports.cleanupSharedContext = cleanupSharedContext;
+const fs = __importStar(require("fs-extra"));
+const glob_1 = require("glob");
+const path = __importStar(require("path"));
+const treeSitterLayer_1 = require("../semantic/treeSitter/treeSitterLayer");
+const contextBuilder_1 = require("../semantic/contextBuilder");
+const types_1 = require("../semantic/types");
+const fileMapper_1 = require("../../utils/fileMapper");
+const frontMatter_1 = require("../../utils/frontMatter");
+const scaffoldStructures_1 = require("../../generators/shared/scaffoldStructures");
+const documentationGenerator_1 = require("../../generators/documentation/documentationGenerator");
+const semantic_1 = require("../semantic");
+const agentGenerator_1 = require("../../generators/agents/agentGenerator");
+const skillGenerator_1 = require("../../generators/skills/skillGenerator");
+const planGenerator_1 = require("../../generators/plans/planGenerator");
+const stack_1 = require("../stack");
+const qa_1 = require("../qa");
+const policyService_1 = require("./policyService");
+const sensorCatalogService_1 = require("./sensorCatalogService");
+const shared_1 = require("../shared");
+const skills_1 = require("../../workflow/skills");
+const gitignoreManager_1 = require("../../utils/gitignoreManager");
+function createInternalTool(description, execute) {
+    return { description, execute };
+}
+async function collectScaffoldFiles(outputDir, target = 'all') {
+    const files = [];
+    if (target === 'all' || target === 'docs') {
+        const docsDir = path.join(outputDir, 'docs');
+        if (await fs.pathExists(docsDir)) {
+            const docFiles = await (0, glob_1.glob)('**/*.md', { cwd: docsDir, nodir: true });
+            for (const file of docFiles.sort()) {
+                const filePath = path.join(docsDir, file);
+                if (!await (0, frontMatter_1.needsFill)(filePath))
+                    continue;
+                files.push({
+                    path: filePath,
+                    relativePath: path.join('docs', file),
+                    type: 'doc',
+                    documentName: path.basename(file, '.md'),
+                });
+            }
+        }
+    }
+    if (target === 'all' || target === 'agents') {
+        const agentsDir = path.join(outputDir, 'agents');
+        if (await fs.pathExists(agentsDir)) {
+            const agentFiles = await (0, glob_1.glob)('**/*.md', { cwd: agentsDir, nodir: true });
+            for (const file of agentFiles.sort()) {
+                const filePath = path.join(agentsDir, file);
+                if (!await (0, frontMatter_1.needsFill)(filePath))
+                    continue;
+                files.push({
+                    path: filePath,
+                    relativePath: path.join('agents', file),
+                    type: 'agent',
+                    documentName: path.basename(file, '.md'),
+                });
+            }
+        }
+    }
+    if (target === 'all' || target === 'skills') {
+        const skillsDir = path.join(outputDir, 'skills');
+        if (await fs.pathExists(skillsDir)) {
+            const skillFiles = await (0, glob_1.glob)('**/SKILL.md', { cwd: skillsDir, nodir: true });
+            for (const file of skillFiles.sort()) {
+                const skillPath = path.join(skillsDir, file);
+                if (!await (0, frontMatter_1.needsFill)(skillPath))
+                    continue;
+                const segments = file.split(path.sep);
+                files.push({
+                    path: skillPath,
+                    relativePath: path.join('skills', file),
+                    type: 'skill',
+                    documentName: segments[0],
+                });
+            }
+        }
+    }
+    if (target === 'all' || target === 'plans') {
+        const plansDir = path.join(outputDir, 'plans');
+        if (await fs.pathExists(plansDir)) {
+            const planFiles = await (0, glob_1.glob)('**/*.md', { cwd: plansDir, nodir: true });
+            for (const file of planFiles.sort()) {
+                const filePath = path.join(plansDir, file);
+                if (!await (0, frontMatter_1.needsFill)(filePath))
+                    continue;
+                files.push({
+                    path: filePath,
+                    relativePath: path.join('plans', file),
+                    type: 'plan',
+                    documentName: path.basename(file, '.md'),
+                });
+            }
+        }
+    }
+    if (target === 'all' || target === 'sensors') {
+        const sensorsPath = path.join(outputDir, 'harness', 'sensors.json');
+        if (await fs.pathExists(sensorsPath) && await sensorCatalogNeedsFill(sensorsPath)) {
+            files.push({
+                path: sensorsPath,
+                relativePath: path.join('harness', 'sensors.json'),
+                type: 'sensor',
+                documentName: 'sensors',
+            });
+        }
+    }
+    return files;
+}
+function resolveScaffoldFileInfo(outputDir, filePath) {
+    const resolvedOutputDir = path.resolve(outputDir);
+    const resolvedFilePath = path.resolve(filePath);
+    const relativePath = path.relative(resolvedOutputDir, resolvedFilePath);
+    const segments = relativePath.split(path.sep);
+    if (segments[0] === 'skills' && segments.length >= 3 && segments[2] === 'SKILL.md') {
+        return {
+            path: resolvedFilePath,
+            relativePath,
+            type: 'skill',
+            documentName: segments[1],
+        };
+    }
+    if (segments[0] === 'agents') {
+        return {
+            path: resolvedFilePath,
+            relativePath,
+            type: 'agent',
+            documentName: path.basename(resolvedFilePath, '.md'),
+        };
+    }
+    if (segments[0] === 'plans') {
+        return {
+            path: resolvedFilePath,
+            relativePath,
+            type: 'plan',
+            documentName: path.basename(resolvedFilePath, '.md'),
+        };
+    }
+    if (segments[0] === 'harness' && segments[1] === 'sensors.json') {
+        return {
+            path: resolvedFilePath,
+            relativePath,
+            type: 'sensor',
+            documentName: 'sensors',
+        };
+    }
+    return {
+        path: resolvedFilePath,
+        relativePath,
+        type: 'doc',
+        documentName: path.basename(resolvedFilePath, '.md'),
+    };
+}
+function getDocFillInstructions(fileName) {
+    return `Fill ${fileName} with repository-specific documentation. Use concrete paths, conventions, and examples from this codebase instead of placeholders.`;
+}
+function getAgentFillInstructions(agentType) {
+    return `Fill the ${agentType} playbook with concrete responsibilities, relevant files, workflows, and quality checks used in this repository.`;
+}
+function getSkillFillInstructions(skillSlug) {
+    return `Fill the ${skillSlug} skill with project-specific guidance, examples, and references to real files and conventions from this repository.`;
+}
+function getSensorFillInstructions() {
+    return 'Review .context/harness/sensors.json and rewrite it as a project-specific sensor catalog. Keep the JSON schema valid, keep version at 1, set source to "manual", preserve stack metadata, and keep only commands that make sense for this repository.';
+}
+async function sensorCatalogNeedsFill(filePath) {
+    try {
+        const content = await fs.readJson(filePath);
+        return content.source !== 'manual';
+    }
+    catch {
+        return false;
+    }
+}
+async function hasContent(dirPath) {
+    try {
+        const entries = await fs.readdir(dirPath);
+        return entries.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function hasSkillContent(skillsDir) {
+    try {
+        const entries = await fs.readdir(skillsDir);
+        for (const entry of entries) {
+            const skillDir = path.join(skillsDir, entry);
+            const stat = await fs.stat(skillDir).catch(() => null);
+            if (!stat?.isDirectory())
+                continue;
+            if (await fs.pathExists(path.join(skillDir, 'SKILL.md'))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+async function hasHarnessRuntimeContent(harnessDir) {
+    const runtimeEntries = ['sessions', 'traces', 'artifacts', 'contracts', 'workflows', 'replays', 'datasets'];
+    for (const entry of runtimeEntries) {
+        if (await hasContent(path.join(harnessDir, entry))) {
+            return true;
+        }
+    }
+    return false;
+}
+let treeSitterInstance = null;
+function getTreeSitterLayer() {
+    if (!treeSitterInstance) {
+        treeSitterInstance = new treeSitterLayer_1.TreeSitterLayer();
+    }
+    return treeSitterInstance;
+}
+let sharedContextBuilder = null;
+let cachedContext = null;
+async function getOrBuildContext(repoPath) {
+    if (cachedContext && cachedContext.repoPath === repoPath) {
+        return cachedContext.context;
+    }
+    if (sharedContextBuilder) {
+        await sharedContextBuilder.shutdown();
+        sharedContextBuilder = null;
+    }
+    let builderOptions = {};
+    const configPath = path.join(repoPath, '.context', 'config.json');
+    if (await fs.pathExists(configPath)) {
+        try {
+            const config = await fs.readJson(configPath);
+            if (Array.isArray(config.exclude) && config.exclude.length > 0) {
+                builderOptions = {
+                    exclude: [...new Set([...types_1.DEFAULT_EXCLUDE_PATTERNS, ...config.exclude])]
+                };
+            }
+        }
+        catch {
+            // Ignore malformed config and fall back to defaults.
+        }
+    }
+    sharedContextBuilder = new contextBuilder_1.SemanticContextBuilder(builderOptions);
+    const context = await sharedContextBuilder.buildDocumentationContext(repoPath);
+    cachedContext = { repoPath, context };
+    return context;
+}
+async function cleanupSharedContext() {
+    if (sharedContextBuilder) {
+        await sharedContextBuilder.shutdown();
+        sharedContextBuilder = null;
+    }
+    cachedContext = null;
+}
+exports.readFileTool = createInternalTool('Read the contents of a file from the filesystem', async (input) => {
+    const { filePath, encoding = 'utf-8' } = input;
+    try {
+        const content = await fs.readFile(filePath, encoding);
+        return {
+            success: true,
+            content,
+            path: filePath,
+            size: content.length
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+            path: filePath
+        };
+    }
+});
+exports.listFilesTool = createInternalTool('List files matching a glob pattern in the repository', async (input) => {
+    const { pattern, cwd, ignore } = input;
+    try {
+        const files = await (0, glob_1.glob)(pattern, {
+            cwd: cwd || process.cwd(),
+            ignore: ignore || ['node_modules/**', '.git/**', 'dist/**'],
+            absolute: false
+        });
+        return {
+            success: true,
+            files,
+            count: files.length,
+            pattern
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+            pattern
+        };
+    }
+});
+exports.analyzeSymbolsTool = createInternalTool('Analyze symbols in a source file', async (input) => {
+    const { filePath, symbolTypes } = input;
+    try {
+        const treeSitter = getTreeSitterLayer();
+        const analysis = await treeSitter.analyzeFile(filePath);
+        let symbols = analysis.symbols;
+        if (symbolTypes && symbolTypes.length > 0) {
+            symbols = symbols.filter((symbol) => symbolTypes.includes(symbol.kind));
+        }
+        return {
+            success: true,
+            filePath,
+            language: analysis.language,
+            symbols: symbols.map((symbol) => ({
+                name: symbol.name,
+                kind: symbol.kind,
+                line: symbol.location.line,
+                exported: symbol.exported,
+                documentation: symbol.documentation
+            })),
+            imports: analysis.imports.map((imp) => ({
+                source: imp.source,
+                specifiers: imp.specifiers
+            })),
+            exports: analysis.exports.map((exp) => ({
+                name: exp.name,
+                isDefault: exp.isDefault
+            }))
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+            filePath
+        };
+    }
+});
+exports.getFileStructureTool = createInternalTool('Get the directory structure and file listing of a repository', async (input) => {
+    const { rootPath, maxDepth = 3, includePatterns } = input;
+    try {
+        const mapper = new fileMapper_1.FileMapper([]);
+        const structure = await mapper.mapRepository(rootPath, includePatterns || undefined);
+        const filterByDepth = (relativePath) => relativePath.split('/').length <= maxDepth;
+        return {
+            success: true,
+            rootPath: structure.rootPath,
+            totalFiles: structure.totalFiles,
+            totalSize: structure.totalSize,
+            topLevelDirs: structure.topLevelDirectoryStats.map((dir) => ({
+                name: dir.name,
+                fileCount: dir.fileCount
+            })),
+            files: structure.files
+                .filter((file) => filterByDepth(file.relativePath))
+                .slice(0, 200)
+                .map((file) => ({
+                path: file.relativePath,
+                extension: file.extension,
+                size: file.size
+            }))
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+            rootPath
+        };
+    }
+});
+exports.searchCodeTool = createInternalTool('Search for code patterns across files using regex', async (input) => {
+    const { pattern, fileGlob, maxResults = 50, cwd } = input;
+    try {
+        const files = await (0, glob_1.glob)(fileGlob || '**/*.{ts,tsx,js,jsx,py,go,rs,java}', {
+            cwd: cwd || process.cwd(),
+            ignore: ['node_modules/**', '.git/**', 'dist/**', 'build/**'],
+            absolute: true
+        });
+        const regex = new RegExp(pattern, 'gm');
+        const matches = [];
+        for (const file of files) {
+            if (matches.length >= maxResults)
+                break;
+            try {
+                const content = await fs.readFile(file, 'utf-8');
+                const lines = content.split('\n');
+                for (let index = 0; index < lines.length && matches.length < maxResults; index++) {
+                    if (regex.test(lines[index])) {
+                        matches.push({
+                            file: path.relative(cwd || process.cwd(), file),
+                            line: index + 1,
+                            match: lines[index].trim().slice(0, 200),
+                            context: lines.slice(Math.max(0, index - 1), index + 2).join('\n').slice(0, 500)
+                        });
+                    }
+                    regex.lastIndex = 0;
+                }
+            }
+            catch {
+                // Skip unreadable files.
+            }
+        }
+        return {
+            success: true,
+            pattern,
+            matches,
+            totalMatches: matches.length,
+            truncated: matches.length >= maxResults
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+            pattern
+        };
+    }
+});
+exports.checkScaffoldingTool = createInternalTool('Check if .context scaffolding exists and return granular status', async (input) => {
+    if (!input.repoPath) {
+        throw new Error('repoPath is required for checkScaffolding');
+    }
+    const outputDir = path.resolve(input.repoPath, '.context');
+    try {
+        const sensorsPath = path.join(outputDir, 'harness', 'sensors.json');
+        const [initialized, docs, agents, skills, plans, workflow, harness, sensors] = await Promise.all([
+            fs.pathExists(outputDir),
+            fs.pathExists(path.join(outputDir, 'docs')).then((exists) => exists ? hasContent(path.join(outputDir, 'docs')) : false),
+            fs.pathExists(path.join(outputDir, 'agents')).then((exists) => exists ? hasContent(path.join(outputDir, 'agents')) : false),
+            fs.pathExists(path.join(outputDir, 'skills')).then((exists) => exists ? hasSkillContent(path.join(outputDir, 'skills')) : false),
+            fs.pathExists(path.join(outputDir, 'plans')).then((exists) => exists ? hasContent(path.join(outputDir, 'plans')) : false),
+            fs.pathExists(path.join(outputDir, 'workflow')).then((exists) => exists ? hasContent(path.join(outputDir, 'workflow')) : false),
+            fs.pathExists(path.join(outputDir, 'harness')).then((exists) => exists ? hasHarnessRuntimeContent(path.join(outputDir, 'harness')) : false),
+            fs.pathExists(sensorsPath)
+        ]);
+        return {
+            initialized,
+            docs,
+            agents,
+            skills,
+            plans,
+            workflow,
+            harness,
+            sensors,
+            outputDir
+        };
+    }
+    catch (error) {
+        return {
+            initialized: false,
+            docs: false,
+            agents: false,
+            skills: false,
+            plans: false,
+            workflow: false,
+            harness: false,
+            sensors: false,
+            outputDir,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+});
+exports.initializeContextTool = createInternalTool('Initialize .context scaffolding and create template files', async (input) => {
+    const { repoPath, type = 'both', outputDir: customOutputDir, semantic = true, include, exclude = [], projectType: overrideProjectType, disableFiltering = false, autoFill = true, skipContentGeneration = true, generateQA = false, generateSkills = true, } = input;
+    const resolvedRepoPath = path.resolve(repoPath);
+    const outputDir = customOutputDir
+        ? path.resolve(customOutputDir)
+        : path.resolve(resolvedRepoPath, '.context');
+    const scaffoldDocs = type === 'docs' || type === 'both';
+    const scaffoldAgents = type === 'agents' || type === 'both';
+    try {
+        if (!await fs.pathExists(resolvedRepoPath)) {
+            return {
+                success: false,
+                status: 'error',
+                outputDir,
+                error: `Repository path does not exist: ${resolvedRepoPath}`
+            };
+        }
+        await fs.ensureDir(outputDir);
+        const runtimeGitignorePatterns = (0, shared_1.getUntrackedContextLayoutEntries)().map((entry) => entry.path);
+        await (0, gitignoreManager_1.ensureGitignorePatterns)(resolvedRepoPath, runtimeGitignorePatterns, {
+            header: '# dotcontext runtime state'
+        });
+        if (exclude.length > 0) {
+            const configPath = path.join(outputDir, 'config.json');
+            let existingConfig = {};
+            if (await fs.pathExists(configPath)) {
+                try {
+                    existingConfig = await fs.readJson(configPath);
+                }
+                catch {
+                    existingConfig = {};
+                }
+            }
+            existingConfig.exclude = exclude;
+            await fs.writeJson(configPath, existingConfig, { spaces: 2 });
+        }
+        const fileMapper = new fileMapper_1.FileMapper(exclude);
+        const repoStructure = await fileMapper.mapRepository(resolvedRepoPath, include);
+        let classification;
+        let projectType = 'unknown';
+        if (!disableFiltering) {
+            const stackDetector = new stack_1.StackDetector();
+            const stackInfo = await stackDetector.detect(resolvedRepoPath);
+            if (overrideProjectType) {
+                projectType = overrideProjectType;
+                classification = {
+                    primaryType: overrideProjectType,
+                    secondaryTypes: [],
+                    confidence: 'high',
+                    reasoning: ['Project type manually specified'],
+                };
+            }
+            else {
+                classification = (0, stack_1.classifyProject)(stackInfo);
+                projectType = classification.primaryType;
+            }
+        }
+        const filteredAgents = disableFiltering ? undefined : (0, stack_1.getAgentsForProjectType)(projectType);
+        const filteredDocs = disableFiltering ? undefined : (0, stack_1.getDocsForProjectType)(projectType);
+        const filteredSkills = disableFiltering ? undefined : (0, stack_1.getSkillsForProjectType)(projectType);
+        let docsGenerated = 0;
+        if (scaffoldDocs) {
+            const docGenerator = new documentationGenerator_1.DocumentationGenerator();
+            docsGenerated = await docGenerator.generateDocumentation(repoStructure, outputDir, { semantic, filteredDocs }, false);
+        }
+        let skillsGenerated = 0;
+        if (generateSkills) {
+            try {
+                const skillGenerator = new skillGenerator_1.SkillGenerator({
+                    repoPath: resolvedRepoPath,
+                    outputDir: path.relative(resolvedRepoPath, outputDir),
+                });
+                const skillResult = await skillGenerator.generate({
+                    skills: filteredSkills,
+                    force: false,
+                });
+                skillsGenerated = skillResult.generatedSkills.length;
+            }
+            catch {
+                skillsGenerated = 0;
+            }
+        }
+        let availableSkills = [];
+        if (generateSkills && skillsGenerated > 0) {
+            try {
+                const registry = (0, skills_1.createSkillRegistry)(resolvedRepoPath);
+                const discovered = await registry.discoverAll();
+                availableSkills = discovered.all.map((skill) => ({
+                    slug: skill.slug,
+                    name: skill.metadata.name,
+                    description: skill.metadata.description,
+                    phases: skill.metadata.phases || [],
+                }));
+            }
+            catch {
+                availableSkills = [];
+            }
+        }
+        let agentsGenerated = 0;
+        if (scaffoldAgents) {
+            const agentGenerator = new agentGenerator_1.AgentGenerator();
+            agentsGenerated = await agentGenerator.generateAgentPrompts(repoStructure, outputDir, { semantic, filteredAgents, availableSkills }, false);
+        }
+        let qaGenerated = 0;
+        if (generateQA) {
+            try {
+                const qaService = new qa_1.QAService();
+                const qaResult = await qaService.generateFromCodebase(resolvedRepoPath);
+                qaGenerated = qaResult.generated.length;
+                await qaService.shutdown();
+            }
+            catch {
+                qaGenerated = 0;
+            }
+        }
+        const sensorCatalogService = new sensorCatalogService_1.HarnessSensorCatalogService({
+            repoPath: resolvedRepoPath,
+            contextPath: outputDir,
+        });
+        const sensorCatalog = await sensorCatalogService.bootstrap();
+        const sensorsGenerated = sensorCatalog.sensors.length;
+        const sensorsPath = sensorCatalogService.configPath;
+        const policyService = new policyService_1.HarnessPolicyService({ repoPath: resolvedRepoPath });
+        const policyPath = path.join(outputDir, 'harness', 'policy.json');
+        let policyGenerated = false;
+        if (!await fs.pathExists(policyPath)) {
+            await policyService.savePolicy(await policyService.createBootstrapPolicy());
+            policyGenerated = true;
+        }
+        const generatedFiles = [];
+        if (scaffoldDocs) {
+            const docFiles = await collectScaffoldFiles(outputDir, 'docs');
+            for (const file of docFiles.filter((entry) => path.basename(entry.path).toLowerCase() !== 'readme.md')) {
+                generatedFiles.push({
+                    path: file.path,
+                    relativePath: file.relativePath,
+                    type: 'doc',
+                    instructions: getDocFillInstructions(path.basename(file.path))
+                });
+            }
+        }
+        if (scaffoldAgents) {
+            const agentFiles = await collectScaffoldFiles(outputDir, 'agents');
+            for (const file of agentFiles) {
+                generatedFiles.push({
+                    path: file.path,
+                    relativePath: file.relativePath,
+                    type: 'agent',
+                    instructions: getAgentFillInstructions(file.documentName)
+                });
+            }
+        }
+        if (generateSkills) {
+            const skillFiles = await collectScaffoldFiles(outputDir, 'skills');
+            for (const file of skillFiles) {
+                generatedFiles.push({
+                    path: file.path,
+                    relativePath: file.relativePath,
+                    type: 'skill',
+                    instructions: getSkillFillInstructions(file.documentName)
+                });
+            }
+        }
+        if (autoFill && await sensorCatalogNeedsFill(sensorsPath)) {
+            generatedFiles.push({
+                path: sensorsPath,
+                relativePath: path.relative(outputDir, sensorsPath),
+                type: 'sensor',
+                instructions: getSensorFillInstructions()
+            });
+        }
+        const pendingWrites = autoFill
+            ? generatedFiles.map((file, index) => ({
+                order: index + 1,
+                actionType: 'WRITE_FILE',
+                filePath: file.path,
+                fileType: file.type,
+                instructions: file.instructions,
+                status: 'pending'
+            }))
+            : [];
+        const codebaseContext = autoFill && !skipContentGeneration
+            ? await getOrBuildContext(resolvedRepoPath).catch(() => undefined)
+            : undefined;
+        const qaOutputDir = path.join(outputDir, 'docs', 'qa');
+        const checklist = [
+            ...pendingWrites.map((item) => `[ ] Fill ${path.relative(resolvedRepoPath, item.filePath)}`),
+            sensorsGenerated > 0
+                ? (await sensorCatalogNeedsFill(sensorsPath)
+                    ? `[ ] Customize harness sensors in ${path.relative(resolvedRepoPath, sensorsPath)}`
+                    : `[x] Loaded ${sensorsGenerated} project-specific harness sensors`)
+                : '[ ] Generate harness sensors',
+            policyGenerated ? '[x] Created harness bootstrap policy' : '[x] Reused existing harness bootstrap policy',
+            qaGenerated > 0
+                ? `[x] Generated ${qaGenerated} optional Q&A helper docs in ${qaOutputDir}`
+                : '[ ] Generate optional Q&A helper docs (opt-in)',
+        ];
+        return {
+            success: true,
+            status: pendingWrites.length > 0 ? 'incomplete' : 'success',
+            complete: pendingWrites.length === 0,
+            instruction: pendingWrites.length > 0
+                ? 'Scaffolding created. Fill each pending file with context-aware content before reporting completion.'
+                : 'Scaffolding created successfully.',
+            outputDir,
+            docsGenerated,
+            agentsGenerated,
+            skillsGenerated,
+            qaGenerated,
+            pendingWrites,
+            requiredActions: pendingWrites,
+            checklist,
+            codebaseContext,
+            classification: classification
+                ? {
+                    projectType: classification.primaryType,
+                    confidence: classification.confidence,
+                    reasoning: classification.reasoning,
+                }
+                : undefined,
+            _metadata: {
+                docsGenerated,
+                agentsGenerated,
+                skillsGenerated,
+                qaGenerated,
+                outputDir,
+                classification: classification
+                    ? {
+                        projectType: classification.primaryType,
+                        confidence: classification.confidence,
+                        reasoning: classification.reasoning,
+                    }
+                    : undefined,
+            },
+            nextStep: pendingWrites.length > 0
+                ? {
+                    action: 'Call fillSingle for each pending file and then write the generated content.',
+                    example: pendingWrites[0]
+                        ? `context({ action: "fillSingle", filePath: "${pendingWrites[0].filePath}" })`
+                        : undefined
+                }
+                : undefined
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            status: 'error',
+            complete: false,
+            outputDir,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+});
+exports.scaffoldPlanTool = createInternalTool('Create a plan template in .context/plans/', async (input) => {
+    const { planName, repoPath, outputDir: customOutputDir, title, summary, semantic = true, autoFill = true, } = input;
+    if (!repoPath) {
+        throw new Error('repoPath is required for scaffoldPlan');
+    }
+    const resolvedRepoPath = path.resolve(repoPath);
+    const outputDir = customOutputDir
+        ? path.resolve(customOutputDir)
+        : path.resolve(resolvedRepoPath, '.context');
+    try {
+        const stackDetector = new stack_1.StackDetector();
+        const stackInfo = await stackDetector.detect(resolvedRepoPath);
+        const classification = (0, stack_1.classifyProject)(stackInfo);
+        const filteredAgents = (0, stack_1.getAgentsForProjectType)(classification.primaryType);
+        const filteredDocs = (0, stack_1.getDocsForProjectType)(classification.primaryType);
+        const planGenerator = new planGenerator_1.PlanGenerator();
+        const enableSemantic = autoFill && semantic;
+        const result = await planGenerator.generatePlan({
+            planName,
+            outputDir,
+            title,
+            summary,
+            force: true,
+            verbose: false,
+            semantic: enableSemantic,
+            projectPath: enableSemantic ? resolvedRepoPath : undefined,
+            selectedAgentTypes: filteredAgents,
+            selectedDocKeys: filteredDocs,
+        });
+        const planContent = await fs.readFile(result.planPath, 'utf-8');
+        return {
+            success: true,
+            status: autoFill ? 'incomplete' : 'success',
+            complete: !autoFill,
+            instruction: autoFill
+                ? 'Plan scaffold created. Fill it with concrete phases, responsibilities, and acceptance criteria.'
+                : 'Plan scaffold created successfully.',
+            planPath: result.planPath,
+            planContent,
+            classification: {
+                projectType: classification.primaryType,
+                confidence: classification.confidence,
+                reasoning: classification.reasoning,
+            },
+            nextStep: autoFill
+                ? {
+                    action: 'Call fillSingle with the generated plan path.',
+                    example: `context({ action: "fillSingle", filePath: "${result.planPath}" })`,
+                }
+                : undefined
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            status: 'error',
+            complete: false,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+});
+exports.listFilesToFillTool = createInternalTool('List scaffold files that still need to be filled', async (input) => {
+    const { repoPath, outputDir: customOutputDir, target = 'all' } = input;
+    const resolvedRepoPath = path.resolve(repoPath);
+    const outputDir = customOutputDir
+        ? path.resolve(customOutputDir)
+        : path.resolve(resolvedRepoPath, '.context');
+    try {
+        if (!await fs.pathExists(outputDir)) {
+            return {
+                success: false,
+                error: `Scaffold directory does not exist: ${outputDir}. Run context init first.`
+            };
+        }
+        const files = await collectScaffoldFiles(outputDir, target);
+        return {
+            success: true,
+            files,
+            totalCount: files.length,
+            instructions: `Found ${files.length} files to fill. Call fillSingle for each file path.`
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+});
+exports.fillSingleFileTool = createInternalTool('Build semantic context for filling a single scaffold file', async (input) => {
+    const resolvedRepoPath = path.resolve(input.repoPath);
+    const resolvedFilePath = path.resolve(input.filePath);
+    try {
+        if (!await fs.pathExists(resolvedFilePath)) {
+            return {
+                success: false,
+                error: `File does not exist: ${resolvedFilePath}`
+            };
+        }
+        const semanticContext = await getOrBuildContext(resolvedRepoPath);
+        const currentContent = await fs.readFile(resolvedFilePath, 'utf-8');
+        const fileInfo = resolveScaffoldFileInfo(path.join(resolvedRepoPath, '.context'), resolvedFilePath);
+        const structure = fileInfo.type === 'sensor'
+            ? undefined
+            : (0, scaffoldStructures_1.getScaffoldStructure)(fileInfo.documentName);
+        if (fileInfo.type === 'sensor') {
+            const sensorCatalogService = new sensorCatalogService_1.HarnessSensorCatalogService({
+                repoPath: resolvedRepoPath,
+                contextPath: path.join(resolvedRepoPath, '.context'),
+            });
+            const currentCatalog = await sensorCatalogService.load();
+            return {
+                success: true,
+                filePath: resolvedFilePath,
+                fileType: fileInfo.type,
+                documentName: fileInfo.documentName,
+                semanticContext,
+                currentContent,
+                currentCatalog,
+                instructions: `Use semanticContext and currentContent to rewrite ${resolvedFilePath} as a complete JSON sensor catalog tailored to this repository. Keep version at 1, set source to "manual", preserve stack metadata, and keep only relevant sensors with real commands for this project.`
+            };
+        }
+        return {
+            success: true,
+            filePath: resolvedFilePath,
+            fileType: fileInfo.type,
+            documentName: fileInfo.documentName,
+            semanticContext,
+            scaffoldStructure: structure ? (0, scaffoldStructures_1.serializeStructureForAI)(structure) : undefined,
+            currentContent,
+            instructions: `Use semanticContext and scaffoldStructure to generate complete markdown content for ${resolvedFilePath}. Write repository-specific content without placeholders.`
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+});
+exports.fillScaffoldingTool = createInternalTool('Build semantic context for filling scaffold files', async (input) => {
+    const { repoPath, outputDir: customOutputDir, target = 'all', offset = 0, limit = 3, } = input;
+    const resolvedRepoPath = path.resolve(repoPath);
+    const outputDir = customOutputDir
+        ? path.resolve(customOutputDir)
+        : path.resolve(resolvedRepoPath, '.context');
+    try {
+        if (!await fs.pathExists(resolvedRepoPath)) {
+            return {
+                success: false,
+                error: `Repository path does not exist: ${resolvedRepoPath}`
+            };
+        }
+        if (!await fs.pathExists(outputDir)) {
+            return {
+                success: false,
+                error: `Scaffold directory does not exist: ${outputDir}. Run context init first.`
+            };
+        }
+        const semanticContext = await getOrBuildContext(resolvedRepoPath);
+        const allFiles = await collectScaffoldFiles(outputDir, target);
+        const effectiveLimit = limit === 0 ? allFiles.length : limit;
+        const paginatedFiles = allFiles.slice(offset, offset + effectiveLimit);
+        const files = await Promise.all(paginatedFiles.map(async (fileInfo) => {
+            const currentContent = await fs.readFile(fileInfo.path, 'utf-8');
+            const structure = fileInfo.type === 'sensor'
+                ? undefined
+                : (0, scaffoldStructures_1.getScaffoldStructure)(fileInfo.documentName);
+            return {
+                path: fileInfo.path,
+                relativePath: fileInfo.relativePath,
+                type: fileInfo.type,
+                documentName: fileInfo.documentName,
+                fillInstructions: fileInfo.type === 'sensor' ? getSensorFillInstructions() : undefined,
+                scaffoldStructure: structure ? (0, scaffoldStructures_1.serializeStructureForAI)(structure) : undefined,
+                currentContent
+            };
+        }));
+        return {
+            success: true,
+            semanticContext,
+            files,
+            totalCount: allFiles.length,
+            offset,
+            limit: effectiveLimit,
+            hasMore: offset + effectiveLimit < allFiles.length,
+            instructions: 'Generate content for each file using the shared semanticContext and each file-specific scaffoldStructure, then write the result back to the file path.'
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+});
+exports.getCodebaseMapTool = createInternalTool('Get persisted semantic snapshot data and auto-refresh it on read', async (input) => {
+    if (!input.repoPath) {
+        throw new Error('repoPath is required for getCodebaseMap');
+    }
+    const section = input.section || 'all';
+    try {
+        const snapshotService = new semantic_1.SemanticSnapshotService();
+        const result = await snapshotService.ensureFreshSection(input.repoPath, section);
+        return {
+            success: true,
+            section,
+            data: result.data,
+            mapPath: result.path,
+            source: result.source,
+            fresh: result.fresh,
+            refreshed: result.refreshed,
+            refreshReason: result.refreshReason,
+            generatedAt: result.manifest?.generatedAt ?? null,
+            schemaVersion: result.manifest?.schemaVersion ?? null,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            section,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+});
+exports.TOOL_NAMES = [
+    'readFile',
+    'listFiles',
+    'analyzeSymbols',
+    'getFileStructure',
+    'searchCode',
+    'checkScaffolding',
+    'initializeContext',
+    'scaffoldPlan',
+    'fillScaffolding',
+    'listFilesToFill',
+    'fillSingleFile',
+    'getCodebaseMap'
+];
+//# sourceMappingURL=contextTools.js.map