@weftlet/toolkit 0.0.0-stage → 0.1.0

package/dist/interfaces/cli.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+// Modified for standalone extraction; see docs/extraction-manifest.json.
+import "../../runtime-check.mjs";
+import { resolve } from 'node:path';
+import process from 'node:process';
+import { createContextGraphApplication } from "../application/application.js";
+import { compileOntologyAtExactCheckout } from "../extraction/ontology.js";
+import { visualizeContextPack } from "../visualization/visualization.js";
+import { buildWorkingOverlay } from "../application/overlay.js";
+import { RdfEvidenceGraph } from "../graph/rdf.js";
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+import { analyzeArchitecture } from "../governance/governance.js";
+import { FileSnapshotStore } from "../storage/storage.js";
+import { diagnoseSetup } from "./doctor.js";
+import { runInit } from "./init.js";
+import { loadConfig } from "../configuration/config.js";
+function valueAfter(args, name) {
+    const index = args.indexOf(name);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+function valuesAfter(args, name) {
+    const values = [];
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] === name && args[index + 1])
+            values.push(args[index + 1]);
+    }
+    return values;
+}
+function defaultConfigPath() {
+    const local = resolve('context-graph.config.json');
+    return local;
+}
+export function impactRequestFromArgs(args) {
+    return {
+        snapshotId: valueAfter(args, '--snapshot'),
+        ownerDocument: valueAfter(args, '--owner-doc'),
+        task: valueAfter(args, '--task'),
+        checklistItems: valuesAfter(args, '--checklist'),
+        changedFiles: valuesAfter(args, '--changed-file'),
+        symbols: valuesAfter(args, '--symbol'),
+        capabilities: valuesAfter(args, '--capability'),
+        maxFacts: valueAfter(args, '--max-facts') ? Number(valueAfter(args, '--max-facts')) : undefined,
+        maxDepth: valueAfter(args, '--max-depth') ? Number(valueAfter(args, '--max-depth')) : undefined,
+        continuation: valueAfter(args, '--continuation'),
+    };
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.includes('--help') || !args.length) {
+        process.stdout.write('weftlet init|config show|config validate|doctor|hydrate|overlay|impact scan|sparql|validate|govern|visualize|diagnostics show|invariant check|clean-compare|ontology compile\nUse --config <file>; queries accept --snapshot <id>. impact scan accepts --changed-file, --capability, --max-facts, --max-depth, --continuation.\ninit [--yes] [--directory <project>] [--config <file>] [--repository-id <id>] [--code-root <path>] [--semantic-source <path>] [--evidence-root <path>] [--model <name>] [--no-gitignore]\nSource flags may be repeated. init never overwrites an existing config. See README.md for examples.\n');
+        return;
+    }
+    if (args[0] === 'init') {
+        await runInit(args.slice(1));
+        return;
+    }
+    if (args[0] === 'config') {
+        if (!['show', 'validate'].includes(args[1] ?? ''))
+            throw new Error('Usage: context-graph config show|validate [--config <file>]');
+        const loaded = await loadConfig(valueAfter(args, '--config') ?? defaultConfigPath());
+        process.stdout.write(`${JSON.stringify(args[1] === 'show' ? loaded.config :
+            { valid: true, configPath: loaded.configPath, repositoryRoot: loaded.repositoryRoot }, null, 2)}\n`);
+        return;
+    }
+    if (args[0] === 'govern') {
+        const policyFile = resolve(valueAfter(args, '--policy') ?? 'architecture.policy.json');
+        const policy = JSON.parse(await readFile(policyFile, 'utf8'));
+        const result = await analyzeArchitecture(dirname(policyFile), policy, basename(policyFile));
+        await new FileSnapshotStore(join(dirname(policyFile), '.context-graph')).write(result.snapshot);
+        const reportPath = valueAfter(args, '--output');
+        if (reportPath) {
+            await mkdir(dirname(resolve(reportPath)), { recursive: true });
+            await writeFile(resolve(reportPath), `${JSON.stringify(result, null, 2)}\n`);
+            process.stdout.write(`${JSON.stringify({ passed: result.passed, findings: result.findings.length, snapshotId: result.snapshot.manifest.snapshotId, reportPath })}\n`);
+        }
+        else
+            process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        if (!result.passed)
+            process.exitCode = 1;
+        return;
+    }
+    const configPath = valueAfter(args, '--config') ?? defaultConfigPath();
+    if (args[0] === 'doctor') {
+        process.stdout.write(`${JSON.stringify(await diagnoseSetup(configPath), null, 2)}\n`);
+        return;
+    }
+    const application = await createContextGraphApplication(configPath);
+    const [command, subcommand] = args;
+    if (command === 'sparql' || command === 'validate') {
+        const id = valueAfter(args, '--snapshot');
+        const snapshot = id ? await application.snapshotStore.read(id) :
+            await application.snapshotStore.readHead(application.headName);
+        if (!snapshot)
+            throw new Error('No graph snapshot is available');
+        const graph = new RdfEvidenceGraph(snapshot);
+        if (command === 'validate') {
+            const report = await graph.validate();
+            process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+            if (!report.conforms)
+                process.exitCode = 1;
+        }
+        else {
+            const query = valueAfter(args, '--query-file');
+            if (!query)
+                throw new Error('sparql requires --query-file <local SELECT query>');
+            process.stdout.write(`${JSON.stringify(await graph.select(await readFile(query, 'utf8')), null, 2)}\n`);
+        }
+        return;
+    }
+    if (command === 'overlay') {
+        const base = valueAfter(args, '--base-snapshot');
+        if (!base)
+            throw new Error('overlay requires --base-snapshot <committed snapshot ID>');
+        const result = await buildWorkingOverlay(application.repository, application.config, application.snapshotStore, application.storageRoot, base, valueAfter(args, '--agent'));
+        process.stdout.write(`${JSON.stringify(result.manifest, null, 2)}\n`);
+        return;
+    }
+    if (command === 'hydrate') {
+        const controller = new AbortController();
+        const cancel = () => controller.abort();
+        process.once('SIGINT', cancel);
+        const scope = await application.scopeResolver?.resolve(impactRequestFromArgs(args));
+        const result = await application.hydrator.hydrate({
+            ref: valueAfter(args, '--ref') ?? 'HEAD',
+            headName: scope?.headName ?? application.headName,
+            semanticSources: scope?.semanticSources,
+            forceSemantic: args.includes('--force-semantic'),
+            signal: controller.signal,
+            onProgress: args.includes('--quiet') ? undefined : (event) => process.stderr.write(`[context-graph] ${event.phase}${event.total === undefined ? '' : ` ${event.completed}/${event.total}`}\n`),
+        });
+        process.removeListener('SIGINT', cancel);
+        process.stdout.write(`${JSON.stringify({
+            snapshotId: result.snapshot.manifest.snapshotId,
+            commitSha: result.snapshot.manifest.commitSha,
+            contentDigest: result.snapshot.manifest.contentDigest,
+            semanticExtracted: result.semanticExtracted,
+            semanticReused: result.semanticReused,
+        }, null, 2)}\n`);
+        return;
+    }
+    if (command === 'clean-compare') {
+        const result = await application.snapshotChecks.compare(impactRequestFromArgs(args), valueAfter(args, '--ref') ?? 'HEAD');
+        process.stdout.write(`${result.snapshot.manifest.contentDigest}\n`);
+        return;
+    }
+    if (command === 'impact' && subcommand === 'scan') {
+        const pack = await application.queryService.scan(impactRequestFromArgs(args));
+        process.stdout.write(args.includes('--json') ? `${JSON.stringify(pack, null, 2)}\n` : `${pack.markdown}\n`);
+        return;
+    }
+    if (command === 'visualize') {
+        const outputPath = valueAfter(args, '--output');
+        if (!outputPath)
+            throw new Error('visualize requires --output <path>');
+        const result = await visualizeContextPack(application.queryService, impactRequestFromArgs(args), {
+            outputPath,
+            format: valueAfter(args, '--format'),
+            force: args.includes('--force'),
+            sourceUrlTemplate: valueAfter(args, '--source-url-template'),
+        });
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        return;
+    }
+    if (command === 'invariant' && subcommand === 'check') {
+        const snapshot = await application.snapshotChecks.read(impactRequestFromArgs(args), valueAfter(args, '--ref') ?? 'HEAD');
+        process.stdout.write(`${JSON.stringify(snapshot.invariants, null, 2)}\n`);
+        if (snapshot.invariants.some((item) => item.status !== 'pass'))
+            process.exitCode = 1;
+        return;
+    }
+    if (command === 'diagnostics' && subcommand === 'show') {
+        const snapshotId = valueAfter(args, '--snapshot');
+        if (!snapshotId)
+            throw new Error('diagnostics show requires --snapshot <snapshotId> from a Context Pack');
+        const snapshot = await application.snapshotStore.read(snapshotId);
+        if (!snapshot)
+            throw new Error('No graph snapshot is available for that identifier');
+        process.stdout.write(`${JSON.stringify({
+            snapshotId,
+            diagnostics: snapshot.diagnostics ?? [],
+            legacyUnclassified: snapshot.unresolved,
+            invariants: snapshot.invariants,
+        }, null, 2)}\n`);
+        return;
+    }
+    if (command === 'ontology' && subcommand === 'compile') {
+        const result = await compileOntologyAtExactCheckout(application.repository, application.ontologyCompiler, valueAfter(args, '--ref') ?? 'HEAD');
+        process.stdout.write(`${JSON.stringify({ digest: result.digest, files: result.rdfFiles }, null, 2)}\n`);
+        return;
+    }
+    throw new Error('Usage: weftlet hydrate|clean-compare|impact scan|diagnostics show --snapshot <id>|invariant check|ontology compile|visualize --output <file.html|file.dot|file.svg>');
+}
+main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`);
+    process.exitCode = 1;
+});

package/dist/interfaces/doctor.d.ts

@@ -0,0 +1,25 @@
+/** Reads readiness only. It never installs tools, prints credentials, or starts a model. */
+export declare function diagnoseSetup(configPath: string): Promise<{
+    node: string;
+    repositoryRoot: string;
+    gitAvailable: boolean;
+    savedSnapshot: string | null;
+    semanticProvider: "codex-cli" | "module";
+    codexAvailable: boolean;
+    codexAuthMode: "chatgpt" | "api-key" | undefined;
+    codexLoginMode: import("../extraction/codex-auth.js").CodexLoginMode | undefined;
+    codexApiKeyEnv: string | undefined;
+    codexApiKeyPresent: boolean | undefined;
+    codexAuthenticated: boolean | null;
+    codexAuthStatus: string;
+    moduleProvider: string | undefined;
+    ontologyBackend: "rdf" | "opencaesar";
+    dockerReady: boolean | undefined;
+    limits: {
+        maxDocuments: number;
+        maxSourceBytes: number;
+        timeoutMs: number;
+        retries: number;
+    };
+    note: string;
+}>;

package/dist/interfaces/doctor.js

@@ -0,0 +1,49 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { loadConfig } from "../configuration/config.js";
+import { resolveStorageRoot } from "../configuration/cache.js";
+import { FileSnapshotStore } from "../storage/storage.js";
+import { readCodexLoginMode, semanticCommandEnvironment } from '../extraction/codex-auth.js';
+/** Reads readiness only. It never installs tools, prints credentials, or starts a model. */
+export async function diagnoseSetup(configPath) {
+    const { config, repositoryRoot } = await loadConfig(configPath);
+    const execute = promisify(execFile);
+    const probe = async (name, args) => {
+        try {
+            const result = await execute(name, args, { cwd: repositoryRoot, timeout: 5000, maxBuffer: 8192 });
+            return { available: true, output: `${result.stdout}${result.stderr}` };
+        }
+        catch {
+            return { available: false, output: '' };
+        }
+    };
+    const git = await probe('git', ['--version']);
+    const codex = await probe(process.platform === 'win32' ? 'codex.exe' : 'codex', ['--version']);
+    const auth = config.semantic.auth;
+    const authMode = config.semantic.provider === 'codex-cli' ? auth?.mode ?? 'chatgpt' : undefined;
+    const apiKeyEnv = auth?.mode === 'api-key' ? auth.apiKeyEnv ?? 'CODEX_API_KEY' : undefined;
+    const apiKeyPresent = apiKeyEnv ? Boolean(process.env[apiKeyEnv]?.trim()) : undefined;
+    const loginMode = codex.available && authMode === 'chatgpt'
+        ? await readCodexLoginMode(process.platform === 'win32' ? 'codex.exe' : 'codex', semanticCommandEnvironment(process.env))
+        : undefined;
+    const docker = config.ontology.backend === 'opencaesar' ? await probe('docker', ['info']) : undefined;
+    const saved = await new FileSnapshotStore(resolveStorageRoot(repositoryRoot, config)).readHead('default');
+    return {
+        node: process.version, repositoryRoot, gitAvailable: git.available,
+        savedSnapshot: saved?.manifest.snapshotId ?? null,
+        semanticProvider: config.semantic.provider,
+        codexAvailable: codex.available,
+        codexAuthMode: authMode,
+        codexLoginMode: loginMode,
+        codexApiKeyEnv: apiKeyEnv,
+        codexApiKeyPresent: apiKeyPresent,
+        codexAuthenticated: authMode === 'chatgpt' ? loginMode === 'chatgpt' : null,
+        codexAuthStatus: authMode === 'api-key' ? (apiKeyPresent ? 'key-present-unverified' : 'missing-key')
+            : authMode === 'chatgpt' ? (loginMode === 'chatgpt' ? 'chatgpt-login-present' : 'chatgpt-login-required') : 'not-applicable',
+        moduleProvider: config.semantic.provider === 'module' ? 'loaded only during extraction; trusted local code' : undefined,
+        ontologyBackend: config.ontology.backend ?? 'rdf', dockerReady: docker?.available,
+        limits: { maxDocuments: config.semantic.maxDocuments ?? 8, maxSourceBytes: config.semantic.maxSourceBytes ?? 65_536,
+            timeoutMs: config.semantic.timeoutMs ?? 120_000, retries: config.semantic.retries ?? 0 },
+        note: 'Saved evidence remains queryable without model or Docker readiness. No model request was made.',
+    };
+}

package/dist/interfaces/init.d.ts

@@ -0,0 +1,24 @@
+import type { ContextGraphConfig } from "../configuration/config.js";
+export interface InitOptions {
+    directory?: string;
+    configPath?: string;
+    repositoryId?: string;
+    codeRoots?: string[];
+    semanticSources?: string[];
+    evidenceRoots?: string[];
+    model?: string;
+    gitignore?: boolean;
+}
+/** Creates local configuration only; no provider, indexer, Git mutation or install is invoked. */
+export declare function prepareProjectConfig(options?: InitOptions): Promise<{
+    root: string;
+    configPath: string;
+    config: ContextGraphConfig;
+}>;
+export declare function initializeProject(options?: InitOptions): Promise<{
+    root: string;
+    configPath: string;
+    config: ContextGraphConfig;
+}>;
+/** TTY prompts are optional; automation uses --yes and explicit source flags. */
+export declare function runInit(args: readonly string[]): Promise<void>;

package/dist/interfaces/init.js

@@ -0,0 +1,154 @@
+import { lstat, mkdir, readFile, appendFile, writeFile } from 'node:fs/promises';
+import { basename, dirname, isAbsolute, relative, resolve } from 'node:path';
+import { createInterface } from 'node:readline/promises';
+const toPosix = (path) => path.replace(/\\/g, '/');
+async function present(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+/** Creates local configuration only; no provider, indexer, Git mutation or install is invoked. */
+export async function prepareProjectConfig(options = {}) {
+    const root = resolve(options.directory ?? '.');
+    const configPath = resolve(root, options.configPath ?? 'context-graph.config.json');
+    let packageName;
+    if (await present(resolve(root, 'package.json'))) {
+        const manifest = JSON.parse(await readFile(resolve(root, 'package.json'), 'utf8'));
+        if (typeof manifest.name === 'string' && manifest.name.trim())
+            packageName = manifest.name;
+    }
+    const repositoryId = options.repositoryId ?? packageName ?? basename(root);
+    if (!repositoryId.trim())
+        throw new Error('Repository ID must not be empty');
+    const paths = (values) => values.map((path) => {
+        const normalized = toPosix(path).replace(/^\.\//, '');
+        if (!normalized || normalized.startsWith('/') || isAbsolute(path) || /^[A-Za-z]:/.test(normalized) ||
+            normalized.split('/').includes('..'))
+            throw new Error(`Source paths must stay within the repository: ${path}`);
+        return normalized;
+    });
+    const detectedEvidence = [];
+    for (const candidate of ['test', 'tests', '__tests__']) {
+        if (await present(resolve(root, candidate)))
+            detectedEvidence.push(candidate);
+    }
+    const config = {
+        schemaVersion: 1,
+        repositoryRoot: toPosix(relative(dirname(configPath), root)) || '.',
+        repositoryId,
+        namespace: `https://example.test/context/${encodeURIComponent(repositoryId)}/`,
+        semanticSources: paths(options.semanticSources ?? []),
+        approvedIntentSources: [],
+        codeRoots: paths(options.codeRoots ?? [await present(resolve(root, 'src')) ? 'src' : '.']),
+        contractPatterns: [],
+        evidenceRoots: paths(options.evidenceRoots ?? detectedEvidence),
+        semantic: {
+            provider: 'codex-cli', auth: { mode: 'chatgpt' }, model: options.model ?? 'gpt-6-astra', reasoningEffort: 'medium',
+            promptVersion: 'generic-semantic-v3', extractorVersion: '1.1.0', adapterVersion: '1.1.0',
+            ontologyVersion: '1.1.0', minimumConfidence: 0.7, failOnUnresolved: true, concurrency: 1,
+            maxDocuments: 8, maxSourceBytes: 65_536, timeoutMs: 120_000, retries: 0,
+        },
+        scip: { version: '0.4.0', command: 'bundled-scip-typescript',
+            args: ['index', '--no-global-caches', '--infer-tsconfig'] },
+        ontology: { backend: 'rdf', toolVersion: 'rdf-record-v1' },
+        runtimeEvidence: [], storagePath: '.context-graph',
+    };
+    if (!config.semantic.model.trim())
+        throw new Error('Model must not be empty');
+    return { root, configPath, config };
+}
+export async function initializeProject(options = {}) {
+    const prepared = await prepareProjectConfig(options);
+    const { root, configPath, config } = prepared;
+    if (await present(configPath))
+        throw new Error(`Configuration already exists: ${configPath}. Edit it or choose another --config path.`);
+    const ignorePath = resolve(root, '.gitignore');
+    if (configPath === ignorePath)
+        throw new Error('Configuration cannot replace .gitignore');
+    let ignoreContent = '';
+    if (options.gitignore !== false && await present(ignorePath)) {
+        if (!(await lstat(ignorePath)).isFile())
+            throw new Error('.gitignore must be a regular file');
+        ignoreContent = await readFile(ignorePath, 'utf8');
+    }
+    await mkdir(dirname(configPath), { recursive: true });
+    // Exclusive creation prevents a second initializer from overwriting a concurrent writer.
+    await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, { flag: 'wx' });
+    const ignoresStorage = ignoreContent.split(/\r?\n/).some((line) => ['.context-graph', '.context-graph/', '/.context-graph', '/.context-graph/'].includes(line.trim()));
+    if (options.gitignore !== false && !ignoresStorage) {
+        const newline = ignoreContent.includes('\r\n') ? '\r\n' : '\n';
+        await appendFile(ignorePath, `${ignoreContent && !ignoreContent.endsWith('\n') ? newline : ''}.context-graph/${newline}`);
+    }
+    return prepared;
+}
+/** TTY prompts are optional; automation uses --yes and explicit source flags. */
+export async function runInit(args) {
+    const values = new Map();
+    const flags = new Set(['--yes', '--no-gitignore']);
+    const valued = new Set(['--directory', '--config', '--repository-id', '--code-root', '--semantic-source', '--evidence-root', '--model']);
+    for (let i = 0; i < args.length; i++) {
+        const key = args[i];
+        if (flags.has(key))
+            continue;
+        if (!valued.has(key))
+            throw new Error(`Unknown init option: ${key}`);
+        const value = args[++i];
+        if (!value || value.startsWith('--'))
+            throw new Error(`${key} requires a value`);
+        values.set(key, [...(values.get(key) ?? []), value]);
+    }
+    const one = (key) => {
+        const entries = values.get(key);
+        if (entries && entries.length > 1)
+            throw new Error(`${key} may only be supplied once`);
+        return entries?.[0];
+    };
+    const options = {
+        directory: one('--directory'), configPath: one('--config'), repositoryId: one('--repository-id'),
+        model: one('--model'), codeRoots: values.get('--code-root'), semanticSources: values.get('--semantic-source'),
+        evidenceRoots: values.get('--evidence-root'), gitignore: !args.includes('--no-gitignore'),
+    };
+    if (!args.includes('--yes')) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY)
+            throw new Error('Non-interactive setup requires --yes. Use --semantic-source <path> to select documents explicitly.');
+        const defaults = await prepareProjectConfig(options);
+        const prompt = createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            process.stdout.write('Set up a TypeScript context graph. Documents are opt-in; source approval is configured separately.\n');
+            if (!options.repositoryId)
+                options.repositoryId = (await prompt.question(`Repository ID [${defaults.config.repositoryId}]: `)).trim() || defaults.config.repositoryId;
+            if (!options.codeRoots) {
+                const answer = (await prompt.question(`Code roots, comma-separated [${defaults.config.codeRoots.join(', ')}]: `)).trim();
+                if (answer)
+                    options.codeRoots = answer.split(',').map((path) => path.trim()).filter(Boolean);
+            }
+            if (!options.semanticSources) {
+                const answer = (await prompt.question('Document paths, comma-separated [none]: ')).trim();
+                options.semanticSources = answer ? answer.split(',').map((path) => path.trim()).filter(Boolean) : [];
+            }
+            if (!options.model)
+                options.model = (await prompt.question(`Codex model [${defaults.config.semantic.model}]: `)).trim() || defaults.config.semantic.model;
+            const confirm = (await prompt.question(`Write ${defaults.configPath}${options.gitignore ? ' and update .gitignore' : ''}? [Y/n]: `)).trim();
+            if (confirm && !/^y(?:es)?$/i.test(confirm)) {
+                process.stdout.write('Setup cancelled; no files written.\n');
+                return;
+            }
+        }
+        finally {
+            prompt.close();
+        }
+    }
+    const result = await initializeProject(options);
+    process.stdout.write(`Created ${result.configPath}\n`);
+    process.stdout.write(`Selected ${result.config.semanticSources.length} document paths; approved intent sources: none.\n`);
+    process.stdout.write('Review the configuration, select any contracts and owner-approved documents, and commit the inputs you want indexed.\n');
+    const configArg = JSON.stringify(result.configPath);
+    process.stdout.write(`Next: npx @weftlet/toolkit doctor --config ${configArg}\nThen: npx @weftlet/toolkit hydrate --config ${configArg} --ref HEAD\n`);
+    process.stdout.write('Hydration with selected documents uses Codex and may incur model charges. Setup made no model requests.\n');
+}

package/dist/interfaces/mcp-facade.d.ts

@@ -0,0 +1,3 @@
+import type { ImpactQueryService, ImpactScanRequest } from "@weftlet/core";
+export declare const impactScanToolName = "impact.scan";
+export declare function handleImpactScan(service: ImpactQueryService, request: ImpactScanRequest): Promise<import("@weftlet/core").ContextPack>;

package/dist/interfaces/mcp-facade.js

@@ -0,0 +1,4 @@
+export const impactScanToolName = 'impact.scan';
+export async function handleImpactScan(service, request) {
+    return service.scan(request);
+}

package/dist/interfaces/mcp.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../../runtime-check.mjs";

package/dist/interfaces/mcp.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+// Modified for standalone extraction; see docs/extraction-manifest.json.
+import "../../runtime-check.mjs";
+import { resolve } from 'node:path';
+import process from 'node:process';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { createContextGraphApplication } from "../application/application.js";
+import { handleImpactScan, impactScanToolName } from "./mcp-facade.js";
+import { parseImpactScanRequest } from "./request.js";
+async function main() {
+    const local = resolve('context-graph.config.json');
+    const configPath = process.env.CONTEXT_GRAPH_CONFIG ??
+        local;
+    const application = await createContextGraphApplication(configPath);
+    const server = new Server({ name: 'context-graph', version: '0.1.0' }, {
+        capabilities: { tools: {} },
+        instructions: 'Call impact.scan before non-leaf planning or implementation. Pass the active owner document and task/checklist text. Treat product-intent, contract, implementation, and validation coverage gaps as unresolved context, not permission to invent behavior.',
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [
+            {
+                name: impactScanToolName,
+                description: 'Return a bounded, provenance-bearing impact Context Pack for a task, document, file, symbol, or capability.',
+                inputSchema: {
+                    type: 'object',
+                    additionalProperties: false,
+                    properties: {
+                        snapshotId: { type: 'string' },
+                        ownerDocument: { type: 'string' },
+                        task: { type: 'string' },
+                        checklistItems: { type: 'array', items: { type: 'string' } },
+                        changedFiles: { type: 'array', items: { type: 'string' } },
+                        symbols: { type: 'array', items: { type: 'string' } },
+                        capabilities: { type: 'array', items: { type: 'string' } },
+                        maxFacts: { type: 'integer', minimum: 1, maximum: 200 },
+                        maxDepth: { type: 'integer', minimum: 1, maximum: 128 },
+                        continuation: { type: 'string', maxLength: 2048 },
+                    },
+                },
+                annotations: {
+                    readOnlyHint: true,
+                    destructiveHint: false,
+                    idempotentHint: true,
+                    openWorldHint: false,
+                },
+            },
+        ],
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        if (request.params.name !== impactScanToolName) {
+            return {
+                content: [{ type: 'text', text: `Unknown tool: ${request.params.name}` }],
+                isError: true,
+            };
+        }
+        try {
+            const pack = await handleImpactScan(application.queryService, parseImpactScanRequest(request.params.arguments ?? {}));
+            return {
+                content: [
+                    { type: 'text', text: pack.markdown },
+                    { type: 'text', text: JSON.stringify(pack) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
+                isError: true,
+            };
+        }
+    });
+    await server.connect(new StdioServerTransport());
+}
+if (process.env.CONTEXT_GRAPH_MCP_TEST !== '1') {
+    void main().catch((error) => {
+        process.stderr.write(`${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`);
+        process.exitCode = 1;
+    });
+}

package/dist/interfaces/request.d.ts

@@ -0,0 +1,2 @@
+import type { ImpactScanRequest } from "@weftlet/core";
+export declare function parseImpactScanRequest(value: unknown): ImpactScanRequest;

package/dist/interfaces/request.js

@@ -0,0 +1,59 @@
+const allowedFields = new Set([
+    'snapshotId',
+    'ownerDocument',
+    'task',
+    'checklistItems',
+    'changedFiles',
+    'symbols',
+    'capabilities',
+    'maxFacts',
+    'maxDepth',
+    'continuation',
+]);
+function optionalString(value, field) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new Error(`${field} must be a non-empty string`);
+    }
+    return value;
+}
+function optionalStringArray(value, field) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) ||
+        !value.every((item) => typeof item === 'string' && item.trim().length > 0)) {
+        throw new Error(`${field} must be an array of non-empty strings`);
+    }
+    return value;
+}
+export function parseImpactScanRequest(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error('impact.scan arguments must be an object');
+    }
+    const record = value;
+    const unexpected = Object.keys(record).filter((field) => !allowedFields.has(field));
+    if (unexpected.length > 0)
+        throw new Error(`Unknown impact.scan fields: ${unexpected.join(', ')}`);
+    const maxFacts = record.maxFacts;
+    const maxDepth = record.maxDepth;
+    if (maxDepth !== undefined && (!Number.isInteger(maxDepth) || Number(maxDepth) < 1 || Number(maxDepth) > 128)) {
+        throw new Error('maxDepth must be an integer between 1 and 128');
+    }
+    if (maxFacts !== undefined &&
+        (!Number.isInteger(maxFacts) || Number(maxFacts) < 1 || Number(maxFacts) > 200)) {
+        throw new Error('maxFacts must be an integer between 1 and 200');
+    }
+    return {
+        snapshotId: optionalString(record.snapshotId, 'snapshotId'),
+        ownerDocument: optionalString(record.ownerDocument, 'ownerDocument'),
+        task: optionalString(record.task, 'task'),
+        checklistItems: optionalStringArray(record.checklistItems, 'checklistItems'),
+        changedFiles: optionalStringArray(record.changedFiles, 'changedFiles'),
+        symbols: optionalStringArray(record.symbols, 'symbols'),
+        capabilities: optionalStringArray(record.capabilities, 'capabilities'),
+        maxFacts: maxFacts,
+        maxDepth: maxDepth,
+        continuation: optionalString(record.continuation, 'continuation'),
+    };
+}

package/dist/mcp.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import '../runtime-check.mjs';
+import './interfaces/mcp.js';

package/dist/mcp.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+// Stable executable entry point; implementation lives in interfaces/.
+import '../runtime-check.mjs';
+import './interfaces/mcp.js';

package/dist/repository/committed-tree.d.ts

@@ -0,0 +1,2 @@
+/** Materialize committed bytes without registering a worktree or touching the active checkout. */
+export declare function withCommittedTree<T>(repositoryRoot: string, commitSha: string, operation: (root: string) => Promise<T>): Promise<T>;