ast-mcp-server 0.4.0 → 0.5.1

package/dist/services/project.js

@@ -2,7 +2,8 @@ import fs from "node:fs";
 import path from "node:path";
 import { Project } from "ts-morph";
 import { findDeclaration } from "./symbols.js";
-import { createConfigSnapshot } from "./workspace.js";
+import { createConfigSnapshot, createWorkspaceSnapshot } from "./workspace.js";
+import { createInitialProjectStatus, createProjectIdentity, projectStatusToProjection, transitionProjectStatus, } from "./project-status.js";
 const MAX_PROJECT_SESSIONS = 8;
 const projectSessions = new Map();
 const projectRoots = new WeakMap();
@@ -25,7 +26,8 @@ function buildProjectContext(tsConfigFilePath) {
     });
     const projectRoot = path.dirname(tsConfigFilePath);
     projectRoots.set(project, projectRoot);
-    return { project, projectRoot, tsConfigFilePath };
+    const status = createInitialProjectStatus(createProjectIdentity({ projectRoot, configPath: tsConfigFilePath }), { sourceCount: project.getSourceFiles().length });
+    return { project, projectRoot, tsConfigFilePath, status };
 }
 export function createFreshProject(projectRoot) {
     return buildProjectContext(resolveTsConfigPath(projectRoot));
@@ -50,41 +52,113 @@ function getOrCreateSession(projectRoot) {
         configDigest: createConfigSnapshot(tsConfigFilePath).digest,
         queue: Promise.resolve(),
         activeOperations: 0,
+        runningOperations: 0,
+        queuedOperations: 0,
         lastAccessedAt: Date.now(),
     };
     projectSessions.set(tsConfigFilePath, session);
     return session;
 }
+function getQueueStatus(session) {
+    return {
+        state: session.runningOperations > 0 ? "running" : session.queuedOperations > 0 ? "queued" : "idle",
+        active_operations: session.runningOperations,
+        queued_operations: session.queuedOperations,
+    };
+}
 async function synchronizeSession(session) {
-    const currentConfigDigest = createConfigSnapshot(session.context.tsConfigFilePath).digest;
-    if (currentConfigDigest !== session.configDigest) {
-        session.context = buildProjectContext(session.context.tsConfigFilePath);
-        session.configDigest = currentConfigDigest;
-        return;
+    let syncFailureCause = "compiler_rebuild";
+    let currentConfigDigest;
+    try {
+        currentConfigDigest = createConfigSnapshot(session.context.tsConfigFilePath).digest;
+        if (currentConfigDigest !== session.configDigest) {
+            let status = transitionProjectStatus(session.context.status, { type: "config_changed" });
+            status = transitionProjectStatus(status, { type: "compiler_rebuild_started" });
+            const rebuilt = buildProjectContext(session.context.tsConfigFilePath);
+            session.context = { ...rebuilt, status };
+        }
+        const { project, tsConfigFilePath } = session.context;
+        syncFailureCause = "source_change";
+        const refreshSourceFiles = async () => {
+            project.addSourceFilesFromTsConfig(tsConfigFilePath);
+            await Promise.all(project.getSourceFiles().map((sourceFile) => sourceFile.refreshFromFileSystem()));
+        };
+        await refreshSourceFiles();
+        const snapshot = createWorkspaceSnapshot(session.context);
+        if (snapshot.configDigest !== currentConfigDigest) {
+            syncFailureCause = "config_change";
+            throw new Error("Project configuration changed during synchronization. Retry the operation.");
+        }
+        await refreshSourceFiles();
+        const verificationSnapshot = createWorkspaceSnapshot(session.context);
+        if (verificationSnapshot.configDigest !== currentConfigDigest) {
+            syncFailureCause = "config_change";
+            throw new Error("Project configuration changed during synchronization. Retry the operation.");
+        }
+        if (verificationSnapshot.sourceDigest !== snapshot.sourceDigest) {
+            syncFailureCause = "source_change";
+            throw new Error("Project source changed during synchronization. Retry the operation.");
+        }
+        const status = transitionProjectStatus(session.context.status, {
+            type: "sync_succeeded",
+            sourceCount: verificationSnapshot.sourceFileCount,
+            indexedCount: 0,
+            sourceSnapshotFingerprint: `source_${verificationSnapshot.sourceDigest}`,
+            configSnapshotFingerprint: `config_${verificationSnapshot.configDigest}`,
+            canonicalSnapshotFingerprint: `snapshot_${verificationSnapshot.digest}`,
+            at: new Date().toISOString(),
+        });
+        session.context = { ...session.context, status };
+        session.configDigest = verificationSnapshot.configDigest;
+    }
+    catch (error) {
+        const status = transitionProjectStatus(session.context.status, {
+            type: "sync_failed",
+            cause: syncFailureCause,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        session.context = { ...session.context, status };
+        throw error;
     }
-    const { project, tsConfigFilePath } = session.context;
-    project.addSourceFilesFromTsConfig(tsConfigFilePath);
-    await Promise.all(project.getSourceFiles().map((sourceFile) => sourceFile.refreshFromFileSystem()));
 }
-export async function withProject(projectRoot, operation) {
-    const session = getOrCreateSession(projectRoot);
+async function runSessionWithSyncPolicy(session, operation, allowSynchronizationFailure) {
     session.activeOperations += 1;
+    session.queuedOperations += 1;
     let release;
     const previous = session.queue;
     session.queue = new Promise((resolve) => {
         release = resolve;
     });
     await previous;
+    session.queuedOperations -= 1;
+    session.runningOperations += 1;
     try {
-        await synchronizeSession(session);
+        try {
+            await synchronizeSession(session);
+        }
+        catch (error) {
+            if (!allowSynchronizationFailure)
+                throw error;
+        }
         session.lastAccessedAt = Date.now();
         return await operation(session.context);
     }
     finally {
+        session.runningOperations -= 1;
         session.activeOperations -= 1;
         release?.();
     }
 }
+export async function withProject(projectRoot, operation) {
+    return runSessionWithSyncPolicy(getOrCreateSession(projectRoot), operation, false);
+}
+export async function getProjectStatus(projectRoot) {
+    const session = getOrCreateSession(projectRoot);
+    return runSessionWithSyncPolicy(session, (context) => ({
+        ...projectStatusToProjection(context.status),
+        operation_queue: getQueueStatus(session),
+    }), true);
+}
 // Compatibility API for internal scripts. MCP tools should use withProject().
 export function getProject(projectRoot) {
     return createFreshProject(projectRoot).project;

package/dist/services/read-contracts.js

@@ -0,0 +1,159 @@
+export const SNAPSHOT_STATES = Object.freeze([
+    "fresh",
+    "pending",
+    "stale",
+    "rebuilding",
+    "degraded",
+]);
+export function isSnapshotState(value) {
+    return SNAPSHOT_STATES.some((state) => state === value);
+}
+export const FRESHNESS_CAUSES = Object.freeze([
+    "source_change",
+    "config_change",
+    "index_failure",
+    "watcher_failure",
+    "compiler_rebuild",
+]);
+export function isFreshnessCause(value) {
+    return FRESHNESS_CAUSES.some((cause) => cause === value);
+}
+function assertIntegerAtLeast(value, minimum, name) {
+    if (!Number.isInteger(value) || value < minimum) {
+        throw new Error(`${name} must be an integer greater than or equal to ${minimum}.`);
+    }
+}
+export function createFileRange(offset, limit, totalLines) {
+    assertIntegerAtLeast(offset, 0, "File range offset");
+    assertIntegerAtLeast(limit, 1, "File range limit");
+    assertIntegerAtLeast(totalLines, 0, "File range total_lines");
+    return { offset, limit, total_lines: totalLines };
+}
+function projectRelativePath(file) {
+    let unquoted = file.trim();
+    const quote = unquoted[0];
+    if (unquoted.length >= 2 &&
+        (quote === '"' || quote === "'" || quote === "`") &&
+        unquoted.endsWith(quote)) {
+        unquoted = unquoted.slice(1, -1).trim();
+    }
+    const normalized = unquoted.replaceAll("\\", "/");
+    const relative = normalized.startsWith("./") ? normalized.slice(2) : normalized;
+    const segments = relative.split("/");
+    const isWindowsAbsolute = /^[A-Za-z]:/.test(relative);
+    if (relative.length === 0 ||
+        relative.startsWith("/") ||
+        isWindowsAbsolute ||
+        segments.some((segment) => segment.length === 0 || segment === ".." || segment === ".")) {
+        throw new Error("Source location file must be project-relative.");
+    }
+    return relative;
+}
+export function createSourceLocation(file, range) {
+    if (typeof file !== "string" || typeof range !== "object" || range === null) {
+        throw new Error("Source location input is invalid.");
+    }
+    assertIntegerAtLeast(range.start_line, 1, "Source location start_line");
+    if (range.start_column !== undefined) {
+        assertIntegerAtLeast(range.start_column, 1, "Source location start_column");
+    }
+    if (range.end_line !== undefined) {
+        assertIntegerAtLeast(range.end_line, range.start_line, "Source location end_line");
+    }
+    if (range.end_column !== undefined) {
+        assertIntegerAtLeast(range.end_column, 1, "Source location end_column");
+    }
+    if (range.end_line === range.start_line &&
+        range.start_column !== undefined &&
+        range.end_column !== undefined &&
+        range.end_column < range.start_column) {
+        throw new Error("Source location end_column must not precede start_column.");
+    }
+    return {
+        file: projectRelativePath(file),
+        start_line: range.start_line,
+        ...(range.start_column === undefined ? {} : { start_column: range.start_column }),
+        ...(range.end_line === undefined ? {} : { end_line: range.end_line }),
+        ...(range.end_column === undefined ? {} : { end_column: range.end_column }),
+    };
+}
+export const TRUNCATION_REASONS = Object.freeze([
+    "record_limit",
+    "byte_limit",
+    "depth_limit",
+    "edge_limit",
+    "invocation_limit",
+    "serialization_limit",
+]);
+export function isTruncationReason(value) {
+    return TRUNCATION_REASONS.some((reason) => reason === value);
+}
+export function createTruncationMetadata(truncated, reason = null) {
+    if (reason !== null && !isTruncationReason(reason)) {
+        throw new Error(`Unknown truncation reason: ${String(reason)}.`);
+    }
+    if (truncated !== (reason !== null)) {
+        throw new Error("A truncated result requires a machine-readable reason, and a complete result does not.");
+    }
+    return { truncated, reason };
+}
+export function isJsonValue(value) {
+    const ancestors = new Set();
+    function visit(candidate) {
+        if (candidate === null)
+            return true;
+        if (typeof candidate === "string" || typeof candidate === "boolean")
+            return true;
+        if (typeof candidate === "number") {
+            return Number.isFinite(candidate) && !Object.is(candidate, -0);
+        }
+        if (typeof candidate !== "object")
+            return false;
+        if (ancestors.has(candidate))
+            return false;
+        ancestors.add(candidate);
+        try {
+            if ("toJSON" in candidate)
+                return false;
+            if (Array.isArray(candidate)) {
+                if (Object.getPrototypeOf(candidate) !== Array.prototype)
+                    return false;
+                if (Object.getOwnPropertySymbols(candidate).length > 0)
+                    return false;
+                for (let index = 0; index < candidate.length; index += 1) {
+                    if (!Object.hasOwn(candidate, index))
+                        return false;
+                    const descriptor = Object.getOwnPropertyDescriptor(candidate, String(index));
+                    if (descriptor === undefined || !("value" in descriptor) || !visit(descriptor.value)) {
+                        return false;
+                    }
+                }
+                return Object.getOwnPropertyNames(candidate).every((key) => {
+                    if (key === "length")
+                        return true;
+                    const index = Number(key);
+                    return (Number.isInteger(index) &&
+                        index >= 0 &&
+                        index < candidate.length &&
+                        String(index) === key);
+                });
+            }
+            const prototype = Object.getPrototypeOf(candidate);
+            if (prototype !== Object.prototype && prototype !== null)
+                return false;
+            if (Object.getOwnPropertySymbols(candidate).length > 0)
+                return false;
+            return Object.getOwnPropertyNames(candidate).every((key) => {
+                const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+                return (descriptor !== undefined &&
+                    descriptor.enumerable &&
+                    "value" in descriptor &&
+                    visit(descriptor.value));
+            });
+        }
+        finally {
+            ancestors.delete(candidate);
+        }
+    }
+    return visit(value);
+}

package/dist/services/scaffold.js

@@ -0,0 +1,241 @@
+import { LanguageVariant, Node, Scope, ScriptTarget, SyntaxKind, ts, } from "ts-morph";
+import { buildFileOutline } from "./outline.js";
+function assertIdentifier(value, label) {
+    const scanner = ts.createScanner(ScriptTarget.Latest, false, LanguageVariant.Standard, value);
+    const valid = scanner.scan() === SyntaxKind.Identifier && scanner.scan() === SyntaxKind.EndOfFileToken;
+    if (!valid)
+        throw new Error(`${label} must be a valid TypeScript identifier.`);
+}
+function assertBoundedText(value, label, maximum = 10_000) {
+    if (value.trim().length === 0)
+        throw new Error(`${label} must not be empty.`);
+    if (value.length > maximum)
+        throw new Error(`${label} exceeds ${maximum} characters.`);
+}
+function parseFragment(sourceText, label) {
+    const sourceFile = ts.createSourceFile("__ast_scaffold_fragment.ts", sourceText, ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const diagnostics = sourceFile.parseDiagnostics;
+    if (diagnostics.length > 0) {
+        throw new Error(`${label} is not valid TypeScript in its declaration position.`);
+    }
+    return sourceFile;
+}
+function assertTypeFragment(value, label) {
+    assertBoundedText(value, label);
+    const sourceFile = parseFragment(`type __ScaffoldType = ${value};`, label);
+    const declaration = sourceFile.statements[0];
+    if (sourceFile.statements.length !== 1 ||
+        !declaration ||
+        !ts.isTypeAliasDeclaration(declaration) ||
+        declaration.type.getText(sourceFile) !== value.trim()) {
+        throw new Error(`${label} must contain exactly one TypeScript type.`);
+    }
+}
+function assertHeritageFragment(value, label, token) {
+    assertBoundedText(value, label);
+    const keyword = token === SyntaxKind.ExtendsKeyword ? "extends" : "implements";
+    const sourceFile = parseFragment(`class __Scaffold ${keyword} ${value} {}`, label);
+    const declaration = sourceFile.statements[0];
+    const clause = declaration && ts.isClassDeclaration(declaration)
+        ? declaration.heritageClauses?.find((item) => item.token === token)
+        : undefined;
+    if (sourceFile.statements.length !== 1 ||
+        !clause ||
+        clause.types.length !== 1 ||
+        clause.types[0]?.getText(sourceFile) !== value.trim()) {
+        throw new Error(`${label} must contain exactly one TypeScript heritage expression.`);
+    }
+}
+function assertInitializerFragment(value, label) {
+    assertBoundedText(value, label);
+    const sourceFile = parseFragment(`class __Scaffold { value = ${value}; }`, label);
+    const declaration = sourceFile.statements[0];
+    const members = declaration && ts.isClassDeclaration(declaration) ? declaration.members : [];
+    const property = members[0];
+    if (sourceFile.statements.length !== 1 ||
+        members.length !== 1 ||
+        !property ||
+        !ts.isPropertyDeclaration(property) ||
+        property.initializer?.getText(sourceFile) !== value.trim()) {
+        throw new Error(`${label} must contain exactly one TypeScript expression.`);
+    }
+}
+function scopeStructure(modifier) {
+    switch (modifier) {
+        case "public":
+            return { scope: Scope.Public };
+        case "public readonly":
+            return { scope: Scope.Public, isReadonly: true };
+        case "protected":
+            return { scope: Scope.Protected };
+        case "protected readonly":
+            return { scope: Scope.Protected, isReadonly: true };
+        case "private":
+            return { scope: Scope.Private };
+        case "private readonly":
+            return { scope: Scope.Private, isReadonly: true };
+        default:
+            return {};
+    }
+}
+function decoratorStructure(value, label) {
+    assertBoundedText(value, label);
+    const sourceFile = parseFragment(`${value.trim()}\nclass __Scaffold {}`, label);
+    const declaration = sourceFile.statements[0];
+    const decorators = declaration && ts.isClassDeclaration(declaration) && ts.canHaveDecorators(declaration)
+        ? ts.getDecorators(declaration)
+        : undefined;
+    if (sourceFile.statements.length !== 1 ||
+        decorators?.length !== 1 ||
+        decorators[0]?.getText(sourceFile) !== value.trim()) {
+        throw new Error(`${label} must contain exactly one TypeScript decorator.`);
+    }
+    const match = /^@([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)(?:\(([\s\S]*)\))?$/.exec(value.trim());
+    if (!match) {
+        throw new Error(`${label} must use @Name or @Name(arguments) syntax.`);
+    }
+    const argumentText = match[2]?.trim();
+    return {
+        name: match[1],
+        arguments: argumentText ? [argumentText] : [],
+    };
+}
+function validateSpec(spec) {
+    assertIdentifier(spec.className, "class_name");
+    if (spec.methods.length === 0)
+        throw new Error("methods must contain at least one method.");
+    const methodNames = new Set();
+    for (const [index, method] of spec.methods.entries()) {
+        assertIdentifier(method.name, `methods[${index}].name`);
+        if (method.name === "constructor") {
+            throw new Error('Method name "constructor" is reserved for the generated constructor.');
+        }
+        if (methodNames.has(method.name)) {
+            throw new Error("Method names must be unique so pending method selectors are unambiguous.");
+        }
+        methodNames.add(method.name);
+        assertTypeFragment(method.returnType, `methods[${index}].return_type`);
+        const parameterNames = new Set();
+        for (const [paramIndex, parameter] of method.params.entries()) {
+            assertIdentifier(parameter.name, `methods[${index}].params[${paramIndex}].name`);
+            if (parameterNames.has(parameter.name)) {
+                throw new Error(`methods[${index}] parameter names must be unique.`);
+            }
+            parameterNames.add(parameter.name);
+            assertTypeFragment(parameter.type, `methods[${index}].params[${paramIndex}].type`);
+        }
+        for (const [docsIndex, docs] of (method.docs ?? []).entries()) {
+            assertBoundedText(docs, `methods[${index}].docs[${docsIndex}]`);
+            if (docs.includes("*/")) {
+                throw new Error(`methods[${index}].docs[${docsIndex}] must not close its doc comment.`);
+            }
+        }
+    }
+    const constructorParameterNames = new Set();
+    for (const [index, parameter] of spec.constructorParams.entries()) {
+        assertIdentifier(parameter.name, `constructor_params[${index}].name`);
+        if (constructorParameterNames.has(parameter.name)) {
+            throw new Error("Constructor parameter names must be unique.");
+        }
+        constructorParameterNames.add(parameter.name);
+        assertTypeFragment(parameter.type, `constructor_params[${index}].type`);
+    }
+    const propertyNames = new Set();
+    for (const [index, property] of spec.properties.entries()) {
+        assertIdentifier(property.name, `properties[${index}].name`);
+        if (propertyNames.has(property.name))
+            throw new Error("Property names must be unique.");
+        if (methodNames.has(property.name)) {
+            throw new Error("Property names must not collide with generated method names.");
+        }
+        propertyNames.add(property.name);
+        assertTypeFragment(property.type, `properties[${index}].type`);
+        if (property.initializer === undefined) {
+            throw new Error(`properties[${index}] requires an initializer.`);
+        }
+        assertInitializerFragment(property.initializer, `properties[${index}].initializer`);
+    }
+    for (const [index, declaration] of spec.imports.entries()) {
+        assertBoundedText(declaration.from, `imports[${index}].from`, 500);
+        if ([...declaration.from].some((character) => {
+            const codePoint = character.codePointAt(0) ?? 0;
+            return codePoint <= 31 || codePoint === 127;
+        })) {
+            throw new Error(`imports[${index}].from must not contain control characters.`);
+        }
+        if (declaration.default !== undefined) {
+            assertIdentifier(declaration.default, `imports[${index}].default`);
+        }
+        for (const [nameIndex, name] of (declaration.named ?? []).entries()) {
+            assertIdentifier(name, `imports[${index}].named[${nameIndex}]`);
+        }
+    }
+    spec.decorators.forEach((decorator, index) => decoratorStructure(decorator, `decorators[${index}]`));
+    spec.methods.forEach((method, methodIndex) => (method.decorators ?? []).forEach((decorator, decoratorIndex) => decoratorStructure(decorator, `methods[${methodIndex}].decorators[${decoratorIndex}]`)));
+    if (spec.extends !== undefined) {
+        assertHeritageFragment(spec.extends, "extends", SyntaxKind.ExtendsKeyword);
+    }
+    spec.implements.forEach((value, index) => assertHeritageFragment(value, `implements[${index}]`, SyntaxKind.ImplementsKeyword));
+}
+export function buildClassScaffold(project, filePath, spec) {
+    validateSpec(spec);
+    const sourceFile = project.createSourceFile(filePath, "", { overwrite: false });
+    sourceFile.addImportDeclarations(spec.imports.map((declaration) => ({
+        moduleSpecifier: declaration.from,
+        ...(declaration.default ? { defaultImport: declaration.default } : {}),
+        ...(declaration.named?.length ? { namedImports: declaration.named } : {}),
+    })));
+    sourceFile.addClass({
+        name: spec.className,
+        isExported: true,
+        ...(spec.extends ? { extends: spec.extends } : {}),
+        ...(spec.implements.length > 0 ? { implements: spec.implements } : {}),
+        decorators: spec.decorators.map((decorator, index) => decoratorStructure(decorator, `decorators[${index}]`)),
+        ctors: spec.constructorParams.length > 0
+            ? [
+                {
+                    parameters: spec.constructorParams.map((parameter) => ({
+                        name: parameter.name,
+                        type: parameter.type,
+                        ...scopeStructure(parameter.accessModifier),
+                    })),
+                    statements: [],
+                },
+            ]
+            : [],
+        properties: spec.properties.map((property) => ({
+            name: property.name,
+            type: property.type,
+            ...scopeStructure(property.accessModifier),
+            ...(property.initializer !== undefined ? { initializer: property.initializer } : {}),
+        })),
+        methods: spec.methods.map((method, methodIndex) => ({
+            name: method.name,
+            isAsync: method.isAsync,
+            returnType: method.returnType,
+            ...scopeStructure(method.accessModifier),
+            parameters: method.params.map((parameter) => ({
+                name: parameter.name,
+                type: parameter.type,
+            })),
+            decorators: (method.decorators ?? []).map((decorator, decoratorIndex) => decoratorStructure(decorator, `methods[${methodIndex}].decorators[${decoratorIndex}]`)),
+            docs: method.docs ?? [],
+            statements: [`throw new Error("Not implemented: ${spec.className}.${method.name}");`],
+        })),
+    });
+    const classes = sourceFile.getClasses();
+    const allowedStatements = sourceFile
+        .getStatements()
+        .every((statement) => Node.isImportDeclaration(statement) || Node.isClassDeclaration(statement));
+    if (!allowedStatements ||
+        classes.length !== 1 ||
+        classes[0]?.getName() !== spec.className ||
+        classes[0].getMethods().length !== spec.methods.length) {
+        throw new Error("Generated scaffold failed structural postcondition validation.");
+    }
+    return {
+        sourceFile,
+        pendingMethods: spec.methods.map((method) => `${spec.className}.${method.name}`),
+        outline: buildFileOutline(sourceFile).text,
+    };
+}

package/dist/services/symbols.js

@@ -1,4 +1,20 @@
 import { Node, } from "ts-morph";
+export function symbolMatchRank(query, symbol) {
+    const normalizedQuery = query.toLowerCase();
+    const normalizedPath = symbol.symbolPath.toLowerCase();
+    const normalizedName = symbol.name.toLowerCase();
+    const normalizedSelector = `${normalizedPath}@${symbol.line}`;
+    if (normalizedSelector === normalizedQuery)
+        return 0;
+    if (normalizedPath === normalizedQuery)
+        return 1;
+    if (normalizedName === normalizedQuery)
+        return 2;
+    if (normalizedPath.startsWith(normalizedQuery) || normalizedName.startsWith(normalizedQuery)) {
+        return 3;
+    }
+    return 4;
+}
 function namedNode(node) {
     if (Node.isConstructorDeclaration(node))
         return "constructor";

package/dist/services/workspace.js

@@ -65,12 +65,15 @@ export function createConfigSnapshot(rootConfigPath) {
 export function createWorkspaceSnapshot(context) {
     const sourcePaths = context.project
         .getSourceFiles()
-        .map((sourceFile) => sourceFile.getFilePath());
-    const paths = [...sourcePaths, ...createConfigSnapshot(context.tsConfigFilePath).files]
-        .map(canonicalPath)
-        .sort();
-    const files = new Map();
-    for (const filePath of paths) {
+        .map((sourceFile) => canonicalPath(sourceFile.getFilePath()));
+    const configSnapshot = createConfigSnapshot(context.tsConfigFilePath);
+    const sourceFiles = new Map();
+    for (const filePath of [...new Set(sourcePaths)].sort()) {
+        const digest = hashBytes(fs.readFileSync(filePath));
+        sourceFiles.set(filePath, digest);
+    }
+    const files = new Map(sourceFiles);
+    for (const filePath of configSnapshot.files) {
         const digest = hashBytes(fs.readFileSync(filePath));
         const previous = files.get(filePath);
         if (previous && previous !== digest) {
@@ -80,6 +83,9 @@ export function createWorkspaceSnapshot(context) {
     }
     return {
         digest: hashWorkspaceFiles(files),
+        sourceDigest: hashWorkspaceFiles(sourceFiles),
+        configDigest: configSnapshot.digest,
+        sourceFileCount: sourceFiles.size,
         fileCount: files.size,
         files,
     };

package/dist/tools/apply_operation.js

@@ -7,7 +7,7 @@ const AstApplyOperationInputSchema = z.object({
 });
 const AstApplyOperationOutputSchema = z.object({
     operation_id: z.string().uuid(),
-    kind: z.enum(["rename_symbol", "replace_symbol_body"]),
+    kind: z.enum(["rename_symbol", "replace_symbol_body", "scaffold_class"]),
     status: z.literal("applied"),
     applied_at: z.string(),
     affected_files: z.array(z.string()),