@crouton-kit/tsym 0.1.0

package/dist/ts7/checker.js

@@ -0,0 +1,383 @@
+import path from 'node:path';
+import { DiagnosticCategory, SymbolFlags } from 'typescript/unstable/sync';
+import { SyntaxKind, isFunctionLikeDeclaration, isTypeNode } from 'typescript/unstable/ast';
+import * as ts from './ast.js';
+export class RenamePreflightError extends Error {
+    code;
+    site;
+    constructor(code, site, message) {
+        super(message);
+        this.code = code;
+        this.site = site;
+    }
+}
+export function typeAt(host, root, config, file, position, fallback) {
+    return host.withSnapshot((snapshot) => {
+        const project = snapshot.getProject(config);
+        if (!project)
+            throw new Error(`TypeScript project ${config} is not loaded.`);
+        const symbol = project.checker.getSymbolAtPosition(file, position);
+        const type = project.checker.getTypeAtPosition(file, position);
+        if (!symbol || !type)
+            return null;
+        const declaration = symbol.declarations.find((handle) => handle.path === file)?.resolve(project) ?? symbol.declarations[0]?.resolve(project);
+        const signature = renderSignature(project, declaration, type, symbol.name, fallback.kind);
+        const definitions = typeDefinitions(project, root, declaration, fallback.address);
+        return {
+            kind: fallback.kind,
+            modifiers: declaration ? modifiers(declaration) : undefined,
+            signature,
+            documentation: project.checker.getDocumentationCommentOfSymbol(symbol),
+            tags: project.checker.getJsDocTagsOfSymbol(symbol).map((tag) => ({ name: tag.name, text: tag.text ?? '' })),
+            definitions,
+        };
+    });
+}
+export function diagnosticsForFiles(host, root, scopes) {
+    return host.withSnapshot((snapshot) => {
+        const diagnostics = [];
+        for (const scope of scopes) {
+            const project = snapshot.getProject(scope.config);
+            if (!project)
+                throw new Error(`TypeScript project ${scope.config} is not loaded.`);
+            for (const file of scope.files)
+                diagnostics.push(...normalizeDiagnostics(root, project, [
+                    ...project.program.getSyntacticDiagnostics(file),
+                    ...project.program.getSemanticDiagnostics(file),
+                    ...project.program.getSuggestionDiagnostics(file),
+                ]));
+        }
+        return unique(diagnostics);
+    });
+}
+/** Builds rename edits from indexed reference sites and rejects shapes TS7 cannot rewrite safely. */
+export function renameFromOccurrences(host, root, projects, declaration, occurrences, newName) {
+    return host.withSnapshot((snapshot) => {
+        const declarationProject = projects.membership(declaration.file);
+        if (!declarationProject)
+            throw new Error(`The declaration ${declaration.address} is not in a configured TypeScript project.`);
+        const project = snapshot.getProject(declarationProject.config);
+        if (!project)
+            throw new Error(`TypeScript project ${declarationProject.config} is not loaded.`);
+        const renamed = symbolAt(project, declaration.file, declaration.nameSpan.start);
+        if (!renamed)
+            throw new Error(`TypeScript could not resolve ${declaration.address}.`);
+        const target = unalias(project, renamed);
+        assertWorkspaceDeclarations(root, project, target, declaration.address);
+        assertNoStringLiteralRename(root, projects, snapshot, target, declaration.name);
+        const declarationSource = project.program.getSourceFile(declaration.file);
+        if (!declarationSource)
+            throw new Error(`TypeScript could not load ${declaration.file} for rename.`);
+        const declarationPoint = declarationSource.getLineAndCharacterOfPosition(declaration.nameSpan.start);
+        const declarationOccurrence = { file: relative(root, declaration.file), line: declarationPoint.line + 1, col: declarationPoint.character + 1 };
+        const edits = new Map();
+        const sites = new Map();
+        for (const occurrence of [...occurrences, declarationOccurrence, ...shapeOccurrences(root, projects, snapshot, target)])
+            sites.set(address(occurrence), occurrence);
+        for (const occurrence of sites.values()) {
+            const file = path.resolve(root, occurrence.file);
+            const membership = projects.membership(file);
+            if (!membership)
+                throw new Error(`The indexed rename site ${address(occurrence)} is not in a configured TypeScript project.`);
+            const siteProject = snapshot.getProject(membership.config);
+            if (!siteProject)
+                throw new Error(`TypeScript project ${membership.config} is not loaded.`);
+            const source = siteProject.program.getSourceFile(file);
+            if (!source)
+                throw new Error(`TypeScript could not load ${occurrence.file} for rename.`);
+            const position = source.getPositionOfLineAndCharacter(occurrence.line - 1, occurrence.col - 1);
+            const node = nodeAt(source, position);
+            if (!node || !ts.isIdentifier(node))
+                throw new Error(`The indexed rename site ${address(occurrence)} is not an identifier in the current program.`);
+            if (hasComputedName(node))
+                throw new RenamePreflightError('rename-through-computed-name', address(occurrence), `Cannot rename through computed property name at ${address(occurrence)}.`);
+            if (isExplicitImportAliasLocal(siteProject, file, node))
+                continue;
+            if (!renameSymbols(siteProject, file, node).some((candidate) => sameSymbol(siteProject, candidate, target)))
+                throw new Error(`The indexed rename site ${address(occurrence)} no longer resolves to ${declaration.address}.`);
+            if (isExportAlias(node))
+                continue;
+            assertNoConflict(siteProject, target, newName, node, address(occurrence));
+            const edit = editForNode(siteProject, source, node, target, newName);
+            edits.set(`${occurrence.file}:${edit.startUtf16}:${edit.endUtf16}`, { ...occurrence, ...edit });
+        }
+        return [...edits.values()].sort((left, right) => left.file.localeCompare(right.file) || left.startUtf16 - right.startUtf16 || left.endUtf16 - right.endUtf16);
+    });
+}
+function assertWorkspaceDeclarations(root, project, symbol, site) {
+    for (const handle of symbol.declarations) {
+        const declaration = handle.resolve(project);
+        if (declaration && !inside(root, declaration.getSourceFile().fileName))
+            throw new RenamePreflightError('rename-outside-workspace', site, `Cannot rename ${symbol.name}: a declaration is outside the workspace at ${declaration.getSourceFile().fileName}.`);
+    }
+}
+function assertNoStringLiteralRename(root, projects, snapshot, target, name) {
+    for (const scope of projects.records()) {
+        const project = snapshot.getProject(scope.config);
+        if (!project)
+            continue;
+        for (const file of scope.files) {
+            const source = project.program.getSourceFile(file);
+            if (!source)
+                continue;
+            const string = firstStringElementAccess(source, (node) => node.text === name, (argument) => {
+                const symbol = symbolAt(project, file, argument.getStart(source));
+                return !!symbol && sameSymbol(project, symbol, target);
+            });
+            if (string) {
+                const point = source.getLineAndCharacterOfPosition(string.getStart(source));
+                throw new RenamePreflightError('rename-through-string-literal', `${relative(root, file)}:${point.line + 1}:${point.character + 1}`, `Cannot rename through string-literal element access at ${relative(root, file)}:${point.line + 1}:${point.character + 1}.`);
+            }
+        }
+    }
+}
+function shapeOccurrences(root, projects, snapshot, target) {
+    const sites = new Map();
+    const add = (file, source, node) => {
+        if (!ts.isIdentifier(node))
+            return;
+        const point = source.getLineAndCharacterOfPosition(node.getStart(source));
+        const site = { file: relative(root, file), line: point.line + 1, col: point.character + 1 };
+        sites.set(address(site), site);
+    };
+    const visit = (project, file, source, node) => {
+        if (ts.isShorthandPropertyAssignment(node) && ts.isIdentifier(node.name)) {
+            const value = project.checker.getShorthandAssignmentValueSymbol(node);
+            if (value && sameSymbol(project, value, target))
+                add(file, source, node.name);
+        }
+        if (ts.isExportSpecifier(node)) {
+            const value = project.checker.getExportSpecifierLocalTargetSymbol(node);
+            if (value && sameSymbol(project, value, target))
+                add(file, source, node.propertyName ?? node.name);
+        }
+        if (ts.isExportAssignment(node) && !node.isExportEquals && ts.isIdentifier(node.expression)) {
+            const value = symbolAt(project, file, node.expression.getStart(source));
+            if (value && sameSymbol(project, value, target))
+                add(file, source, node.expression);
+        }
+        if (ts.isObjectLiteralElementLike(node)) {
+            const name = 'name' in node ? node.name : undefined;
+            if (name && ts.isIdentifier(name)) {
+                const property = contextualObjectProperty(project, name);
+                if (property && sameSymbol(project, property, target))
+                    add(file, source, name);
+            }
+        }
+        if (ts.isBindingElement(node)) {
+            const bindingName = node.name;
+            if (bindingName && ts.isIdentifier(bindingName)) {
+                const property = destructuredProperty(project, bindingName);
+                if (property && sameSymbol(project, property, target))
+                    add(file, source, bindingName);
+            }
+        }
+        node.forEachChild((child) => visit(project, file, source, child));
+    };
+    for (const scope of projects.records()) {
+        const project = snapshot.getProject(scope.config);
+        if (!project)
+            continue;
+        for (const file of scope.files) {
+            if (projects.membership(file)?.config !== scope.config)
+                continue;
+            const source = project.program.getSourceFile(file);
+            if (source)
+                visit(project, file, source, source);
+        }
+    }
+    return [...sites.values()];
+}
+function firstStringElementAccess(node, namesSymbol, matches) {
+    if (ts.isElementAccessExpression(node) && ts.isStringLiteral(node.argumentExpression) && namesSymbol(node.argumentExpression) && matches(node.argumentExpression))
+        return node.argumentExpression;
+    let found;
+    node.forEachChild((child) => { if (!found)
+        found = firstStringElementAccess(child, namesSymbol, matches); });
+    return found;
+}
+function assertNoConflict(project, target, name, location, site) {
+    const resolved = project.checker.resolveName(name, target.flags, location);
+    if (resolved && !sameSymbol(project, resolved, target))
+        throw conflict(project, name, site, resolved);
+    const member = memberNamed(project, location, name);
+    if (member && !sameSymbol(project, member, target))
+        throw conflict(project, name, site, member);
+}
+function memberNamed(project, location, name) {
+    if (ts.isPropertyAccessExpression(location.parent) && location.parent.name === location) {
+        const type = project.checker.getTypeAtLocation(location.parent.expression);
+        return type && project.checker.getPropertyOfType(type, name);
+    }
+    for (let current = location.parent; current; current = current.parent) {
+        if (ts.isClassLikeDeclaration(current) || ts.isInterfaceDeclaration(current)) {
+            const type = project.checker.getTypeAtLocation(current);
+            return type && project.checker.getPropertyOfType(type, name);
+        }
+    }
+    return undefined;
+}
+function conflict(project, name, site, resolved) {
+    return new RenamePreflightError('rename-conflict', site, `Cannot rename to ${name}: it resolves to ${unalias(project, resolved).name} at ${site}.`);
+}
+function renameSymbols(project, file, node) {
+    const symbols = [
+        ts.isShorthandPropertyAssignment(node.parent) && node.parent.name === node ? project.checker.getShorthandAssignmentValueSymbol(node.parent) : undefined,
+        ts.isExportSpecifier(node.parent) ? project.checker.getExportSpecifierLocalTargetSymbol(node.parent) : undefined,
+        contextualObjectProperty(project, node),
+        destructuredProperty(project, node),
+        symbolAt(project, file, node.getStart(node.getSourceFile())),
+    ];
+    return symbols.filter((symbol) => !!symbol);
+}
+function contextualObjectProperty(project, node) {
+    const member = node.parent;
+    if (!member || !ts.isObjectLiteralElementLike(member) || !('name' in member) || member.name !== node)
+        return undefined;
+    const object = member.parent;
+    const contextual = object && ts.isObjectLiteralExpression(object) ? project.checker.getContextualType(object) : undefined;
+    return contextual && project.checker.getPropertyOfType(contextual, node.text);
+}
+function destructuredProperty(project, node) {
+    const element = node.parent;
+    if (!element || !ts.isBindingElement(element) || element.name !== node || element.propertyName)
+        return undefined;
+    const pattern = element.parent;
+    const declaration = pattern?.parent;
+    if (!pattern || !ts.isObjectBindingPattern(pattern) || !declaration || !ts.isVariableDeclaration(declaration) || !declaration.initializer)
+        return undefined;
+    const type = project.checker.getTypeAtLocation(declaration.initializer);
+    return type && project.checker.getPropertyOfType(type, node.text);
+}
+function isExportAlias(node) { return ts.isExportSpecifier(node.parent) && node.parent.propertyName !== undefined && node.parent.name === node; }
+function isExplicitImportAliasLocal(project, file, node) {
+    const symbol = symbolAt(project, file, node.getStart(node.getSourceFile()));
+    if (!symbol || !(symbol.flags & SymbolFlags.Alias))
+        return false;
+    return symbol.declarations.some((handle) => {
+        const declaration = handle.resolve(project);
+        return !!declaration && ts.isImportSpecifier(declaration) && declaration.propertyName !== undefined;
+    });
+}
+function editForNode(project, source, node, target, newName) {
+    const parent = node.parent;
+    const oldText = node.getText(source);
+    if (ts.isShorthandPropertyAssignment(parent) && parent.name === node) {
+        const value = project.checker.getShorthandAssignmentValueSymbol(parent);
+        if (value)
+            return { startUtf16: node.getStart(source), endUtf16: node.getEnd(), oldText, replacement: sameSymbol(project, value, target) ? `${oldText}: ${newName}` : `${newName}: ${oldText}` };
+    }
+    if (ts.isBindingElement(parent) && parent.name === node && !parent.propertyName && ts.isObjectBindingPattern(parent.parent)) {
+        const binding = symbolAt(project, source.fileName, node.getStart(source));
+        return { startUtf16: node.getStart(source), endUtf16: node.getEnd(), oldText, replacement: binding && sameSymbol(project, binding, target) ? `${oldText}: ${newName}` : `${newName}: ${oldText}` };
+    }
+    if (ts.isExportSpecifier(parent)) {
+        const local = project.checker.getExportSpecifierLocalTargetSymbol(parent);
+        if (local && sameSymbol(project, local, symbolAt(project, source.fileName, node.getStart(source)))) {
+            if (parent.name === node && !parent.propertyName)
+                return { startUtf16: node.getStart(source), endUtf16: node.getEnd(), oldText, replacement: `${newName} as ${oldText}` };
+        }
+    }
+    return { startUtf16: node.getStart(source), endUtf16: node.getEnd(), oldText, replacement: newName };
+}
+function hasComputedName(node) {
+    for (let current = node; current; current = current.parent)
+        if (ts.isComputedPropertyName(current))
+            return true;
+    return false;
+}
+function nodeAt(node, position) {
+    let found;
+    node.forEachChild((child) => { if (position >= child.getFullStart() && position < child.getEnd())
+        found = nodeAt(child, position) ?? found; });
+    return found ?? (node.getStart(node.getSourceFile()) === position ? node : undefined);
+}
+function symbolAt(project, file, position) { return project.checker.getSymbolAtPosition(file, position); }
+function unalias(project, symbol) { return symbol.flags & SymbolFlags.Alias ? project.checker.getAliasedSymbol(symbol) : symbol; }
+function sameSymbol(project, left, right) {
+    const resolvedLeft = unalias(project, left);
+    const resolvedRight = unalias(project, right);
+    return resolvedLeft.id !== 0 && resolvedLeft.id === resolvedRight.id || resolvedLeft.declarations.some((leftDeclaration) => resolvedRight.declarations.some((rightDeclaration) => leftDeclaration.path === rightDeclaration.path && leftDeclaration.index === rightDeclaration.index));
+}
+function address(site) { return `${site.file}:${site.line}:${site.col}`; }
+function renderSignature(project, declaration, type, name, kind) {
+    if (declaration && isFunctionLikeDeclaration(declaration)) {
+        const signature = project.checker.getSignatureFromDeclaration(declaration);
+        if (signature) {
+            const generated = project.checker.signatureToSignatureDeclaration(signature, SyntaxKind.FunctionDeclaration);
+            if (generated) {
+                const text = project.emitter.printNode(generated).replace(/;$/, '');
+                if (text.startsWith('function '))
+                    return `function ${name}${text.slice('function'.length).trimStart()}`;
+            }
+        }
+    }
+    const value = project.checker.typeToString(type, declaration);
+    if (kind === 'interface' || kind === 'class' || kind === 'type' || kind === 'enum')
+        return `${kind} ${name}`;
+    return value;
+}
+function typeDefinitions(project, root, declaration, fallback) {
+    if (!declaration)
+        return [fallback];
+    const nodes = annotationNodes(declaration);
+    const definitions = nodes.flatMap((node) => {
+        const type = project.checker.getTypeFromTypeNode(node);
+        return type ? declarationAddresses(project, root, type.getSymbol()?.declarations ?? []) : [];
+    });
+    return definitions.length > 0 ? uniqueStrings(definitions) : [fallback];
+}
+function annotationNodes(declaration) {
+    const typed = declaration;
+    return [...(typed.parameters ?? []).flatMap((parameter) => parameter.type && isTypeNode(parameter.type) ? [parameter.type] : []), ...(typed.type && isTypeNode(typed.type) ? [typed.type] : [])];
+}
+function declarationAddresses(project, root, declarations) {
+    return declarations.flatMap((handle) => {
+        const declaration = handle.resolve(project);
+        if (!declaration)
+            return [];
+        const source = declaration.getSourceFile();
+        if (!inside(root, source.fileName))
+            return [];
+        const name = declaration.name ?? declaration;
+        const location = source.getLineAndCharacterOfPosition(name.getStart(source));
+        return [`${relative(root, source.fileName)}:${location.line + 1}:${location.character + 1}`];
+    });
+}
+function modifiers(declaration) {
+    const values = declaration.modifiers?.map((modifier) => modifier.getText(declaration.getSourceFile())).filter((modifier) => modifier !== 'async').join(' ');
+    return values || undefined;
+}
+function normalizeDiagnostics(root, project, diagnostics) {
+    return diagnostics.flatMap((diagnostic) => {
+        if (!diagnostic.fileName || !inside(root, diagnostic.fileName))
+            return [];
+        const source = project.program.getSourceFile(diagnostic.fileName);
+        if (!source)
+            return [];
+        const location = source.getLineAndCharacterOfPosition(Math.max(0, diagnostic.pos));
+        return [{
+                file: relative(root, diagnostic.fileName),
+                line: location.line + 1,
+                column: location.character + 1,
+                severity: severity(diagnostic.category),
+                code: diagnostic.code,
+                message: diagnostic.text,
+            }];
+    });
+}
+function severity(category) {
+    if (category === DiagnosticCategory.Warning)
+        return 'warning';
+    if (category === DiagnosticCategory.Error)
+        return 'error';
+    if (category === DiagnosticCategory.Suggestion)
+        return 'suggestion';
+    return 'message';
+}
+function unique(values) {
+    return [...new Map(values.map((diagnostic) => [`${diagnostic.file}:${diagnostic.line}:${diagnostic.column}:${diagnostic.code}:${diagnostic.severity}:${diagnostic.message}`, diagnostic])).values()];
+}
+function uniqueStrings(values) { return [...new Set(values)]; }
+function inside(root, file) { const value = path.relative(root, file); return value === '' || !value.startsWith(`..${path.sep}`) && value !== '..' && !path.isAbsolute(value); }
+function relative(root, file) { return path.relative(root, file).split(path.sep).join('/'); }

package/dist/ts7/projects.d.ts

@@ -0,0 +1,27 @@
+import { Ts7Host } from './api.js';
+export declare const skippedDirectories: ReadonlySet<string>;
+export declare function isProgramFileCandidate(file: string): boolean;
+export interface ConfiguredProject {
+    config: string;
+    files: ReadonlySet<string>;
+    bootstrap: string | null;
+}
+/** Discovers configured projects and applies the first-config ownership rule. */
+export declare class ConfiguredProjects {
+    readonly root: string;
+    readonly program: Ts7Host;
+    private loaded;
+    private projects;
+    constructor(root: string, program: Ts7Host);
+    load(): readonly ConfiguredProject[];
+    /** Re-discovers configured projects after a workspace shape change. */
+    reload(): readonly ConfiguredProject[];
+    membership(file: string): ConfiguredProject | null;
+    refreshFile(file: string): void;
+    sourceFile(file: string): import("typescript/unstable/ast").SourceFile | undefined;
+    anySourceFile(file: string): import("typescript/unstable/ast").SourceFile | undefined;
+    records(): readonly ConfiguredProject[];
+}
+/** Every non-skipped directory in the workspace, including the root. */
+export declare function discoverDirectories(root: string): string[];
+export declare function discoverConfigs(root: string): string[];

package/dist/ts7/projects.js

@@ -0,0 +1,94 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import path from 'node:path';
+const sourceExtensions = new Set(['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs']);
+export const skippedDirectories = new Set(['node_modules', '.git', '.crouter', 'dist', 'build', 'coverage']);
+export function isProgramFileCandidate(file) {
+    const basename = path.basename(file);
+    return sourceExtensions.has(path.extname(file)) || basename === 'tsconfig.json' || basename === 'package.json';
+}
+/** Discovers configured projects and applies the first-config ownership rule. */
+export class ConfiguredProjects {
+    root;
+    program;
+    loaded = false;
+    projects = new Map();
+    constructor(root, program) {
+        this.root = root;
+        this.program = program;
+    }
+    load() {
+        if (this.loaded)
+            return [...this.projects.values()];
+        const configs = discoverConfigs(this.root);
+        const projects = this.program.load(configs);
+        for (const config of configs) {
+            const project = projects.find((candidate) => path.resolve(candidate.configFileName) === config);
+            if (!project)
+                continue;
+            const files = new Set(project.rootFiles.map((file) => path.resolve(file)).filter((file) => workspaceSourceFile(this.root, file)));
+            if (files.size === 0)
+                continue;
+            this.projects.set(config, { config, files, bootstrap: [...files].find((file) => sourceExtensions.has(path.extname(file))) ?? null });
+        }
+        this.loaded = true;
+        if (this.projects.size === 0)
+            throw new Error(`No configured TypeScript project exists under ${this.root}.`);
+        return [...this.projects.values()];
+    }
+    /** Re-discovers configured projects after a workspace shape change. */
+    reload() {
+        this.loaded = false;
+        this.projects.clear();
+        return this.load();
+    }
+    membership(file) {
+        this.load();
+        const absolute = path.resolve(file);
+        for (const project of this.projects.values())
+            if (project.files.has(absolute))
+                return project;
+        return null;
+    }
+    refreshFile(file) { this.program.update({ fileChanges: { changed: [path.resolve(file)] } }); }
+    sourceFile(file) {
+        const project = this.membership(file);
+        return project ? this.program.sourceFile(project.config, path.resolve(file)) : undefined;
+    }
+    anySourceFile(file) { return this.program.sourceFile(undefined, path.resolve(file)); }
+    records() { return [...this.projects.values()]; }
+}
+/** Every non-skipped directory in the workspace, including the root. */
+export function discoverDirectories(root) {
+    const directories = [path.resolve(root)];
+    const visit = (dir) => {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            if (!entry.isDirectory() || skippedDirectories.has(entry.name))
+                continue;
+            const full = path.resolve(dir, entry.name);
+            directories.push(full);
+            visit(full);
+        }
+    };
+    visit(root);
+    return directories;
+}
+export function discoverConfigs(root) {
+    const configs = discoverDirectories(root)
+        .map((directory) => path.join(directory, 'tsconfig.json'))
+        .filter((config) => statOrNull(config)?.isFile() === true);
+    return configs.sort((left, right) => path.relative(root, left).localeCompare(path.relative(root, right)));
+}
+function statOrNull(file) {
+    try {
+        return statSync(file);
+    }
+    catch {
+        return null;
+    }
+}
+function workspaceSourceFile(root, file) {
+    if (!existsSync(file) || !sourceExtensions.has(path.extname(file)))
+        return false;
+    const relative = path.relative(root, file);
+    return relative !== '' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative) && !relative.split(path.sep).some((part) => skippedDirectories.has(part));
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@crouton-kit/tsym",
+  "version": "0.1.0",
+  "description": "Symbol-level reading of a TypeScript codebase for agents.",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "tsym": "./bin/tsym.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && node node_modules/ts5/bin/tsc",
+    "prepack": "npm run build",
+    "typecheck": "node node_modules/ts5/bin/tsc --noEmit",
+    "test": "node --test --import tsx test/*.test.ts",
+    "dev": "tsx src/cli.ts",
+    "validate:crouter": "tsx scripts/validate-crouter.ts",
+    "validate:queries": "tsx scripts/validate-queries.ts"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "dependencies": {
+    "@ast-grep/napi": "^0.45.3",
+    "@ladybugdb/core": "0.20.4",
+    "ts5": "npm:typescript@5.9.3",
+    "typescript": "7.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0"
+  }
+}