@claudiu-ceia/astkit 0.1.0

package/dist/src/code-rank/rank.js

@@ -0,0 +1,185 @@
+import path from "node:path";
+import ts from "typescript";
+import { createService, fromPosition, relativePath } from "../service.js";
+import { collectPatchableFiles } from "../spatch/files.js";
+import { DEFAULT_EXCLUDED_DIRECTORIES, DEFAULT_PATCHABLE_EXTENSIONS, } from "../spatch/types.js";
+export async function rankCode(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const scope = options.scope ?? ".";
+    const resolvedScope = path.resolve(cwd, scope);
+    const files = await collectPatchableFiles({
+        cwd,
+        scope,
+        extensions: options.extensions ?? DEFAULT_PATCHABLE_EXTENSIONS,
+        excludedDirectories: options.excludedDirectories ?? DEFAULT_EXCLUDED_DIRECTORIES,
+    });
+    if (files.length === 0) {
+        return {
+            cwd,
+            scope: resolvedScope,
+            filesScanned: 0,
+            symbolsScanned: 0,
+            symbolsRanked: 0,
+            symbols: [],
+        };
+    }
+    const { service, program, projectRoot } = createService(cwd, files);
+    const checker = program.getTypeChecker();
+    const symbols = [];
+    const seenDeclarations = new Set();
+    for (const filePath of files) {
+        const sourceFile = program.getSourceFile(filePath);
+        if (!sourceFile) {
+            continue;
+        }
+        const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+        if (!moduleSymbol) {
+            continue;
+        }
+        const exportedSymbols = checker.getExportsOfModule(moduleSymbol);
+        for (const exportedSymbol of exportedSymbols) {
+            const declaration = pickDeclarationInFile(exportedSymbol, filePath);
+            if (!declaration) {
+                continue;
+            }
+            const declarationSourceFile = declaration.getSourceFile();
+            const declarationStart = declaration.getStart(declarationSourceFile);
+            const declarationKey = `${declarationSourceFile.fileName}:${declarationStart}:${exportedSymbol.getName()}`;
+            if (seenDeclarations.has(declarationKey)) {
+                continue;
+            }
+            seenDeclarations.add(declarationKey);
+            const stats = collectReferenceStats(service.findReferences(declarationSourceFile.fileName, declarationStart), declarationSourceFile.fileName, projectRoot);
+            const pos = fromPosition(declarationSourceFile, declarationStart);
+            symbols.push({
+                symbol: exportedSymbol.getName(),
+                kind: getDeclarationKind(declaration),
+                file: relativePath(projectRoot, declarationSourceFile.fileName) ||
+                    path.basename(declarationSourceFile.fileName),
+                line: pos.line,
+                character: pos.character,
+                score: computeRankScore(stats),
+                referenceCount: stats.referenceCount,
+                internalReferenceCount: stats.internalReferenceCount,
+                externalReferenceCount: stats.externalReferenceCount,
+                referencingFileCount: stats.referencingFiles.length,
+                referencingFiles: stats.referencingFiles,
+            });
+        }
+    }
+    symbols.sort(compareRankedSymbols);
+    const limit = normalizeLimit(options.limit);
+    const rankedSymbols = limit === null ? symbols : symbols.slice(0, limit);
+    return {
+        cwd,
+        scope: resolvedScope,
+        filesScanned: files.length,
+        symbolsScanned: symbols.length,
+        symbolsRanked: rankedSymbols.length,
+        symbols: rankedSymbols,
+    };
+}
+function collectReferenceStats(references, declarationFile, projectRoot) {
+    if (!references || references.length === 0) {
+        return {
+            referenceCount: 0,
+            internalReferenceCount: 0,
+            externalReferenceCount: 0,
+            referencingFiles: [],
+        };
+    }
+    const seenReferences = new Set();
+    const referencingFiles = new Set();
+    const normalizedDeclarationFile = path.resolve(declarationFile);
+    let referenceCount = 0;
+    let internalReferenceCount = 0;
+    let externalReferenceCount = 0;
+    for (const group of references) {
+        for (const reference of group.references) {
+            const key = `${reference.fileName}:${reference.textSpan.start}:${reference.textSpan.length}`;
+            if (seenReferences.has(key)) {
+                continue;
+            }
+            seenReferences.add(key);
+            if (reference.isDefinition) {
+                continue;
+            }
+            referenceCount += 1;
+            const normalizedReferenceFile = path.resolve(reference.fileName);
+            if (normalizedReferenceFile === normalizedDeclarationFile) {
+                internalReferenceCount += 1;
+            }
+            else {
+                externalReferenceCount += 1;
+            }
+            referencingFiles.add(relativePath(projectRoot, reference.fileName) ||
+                path.basename(reference.fileName));
+        }
+    }
+    return {
+        referenceCount,
+        internalReferenceCount,
+        externalReferenceCount,
+        referencingFiles: [...referencingFiles].sort((left, right) => left.localeCompare(right)),
+    };
+}
+function computeRankScore(stats) {
+    return (stats.externalReferenceCount * 4 +
+        stats.referenceCount +
+        stats.referencingFiles.length * 2);
+}
+function compareRankedSymbols(left, right) {
+    return (right.score - left.score ||
+        right.externalReferenceCount - left.externalReferenceCount ||
+        right.referenceCount - left.referenceCount ||
+        left.file.localeCompare(right.file) ||
+        left.line - right.line ||
+        left.symbol.localeCompare(right.symbol));
+}
+function pickDeclarationInFile(symbol, filePath) {
+    const normalizedFilePath = path.resolve(filePath);
+    const declarations = symbol.getDeclarations();
+    if (!declarations || declarations.length === 0) {
+        return null;
+    }
+    for (const declaration of declarations) {
+        const declarationFile = path.resolve(declaration.getSourceFile().fileName);
+        if (declarationFile === normalizedFilePath &&
+            isRankableDeclaration(declaration)) {
+            return declaration;
+        }
+    }
+    return null;
+}
+function getDeclarationKind(declaration) {
+    if (ts.isFunctionDeclaration(declaration))
+        return "function";
+    if (ts.isClassDeclaration(declaration))
+        return "class";
+    if (ts.isInterfaceDeclaration(declaration))
+        return "interface";
+    if (ts.isTypeAliasDeclaration(declaration))
+        return "type";
+    if (ts.isEnumDeclaration(declaration))
+        return "enum";
+    if (ts.isVariableDeclaration(declaration))
+        return "const";
+    if (ts.isModuleDeclaration(declaration))
+        return "module";
+    return "unknown";
+}
+function isRankableDeclaration(declaration) {
+    return (ts.isFunctionDeclaration(declaration) ||
+        ts.isClassDeclaration(declaration) ||
+        ts.isInterfaceDeclaration(declaration) ||
+        ts.isTypeAliasDeclaration(declaration) ||
+        ts.isEnumDeclaration(declaration) ||
+        ts.isVariableDeclaration(declaration) ||
+        ts.isModuleDeclaration(declaration));
+}
+function normalizeLimit(limit) {
+    if (limit === undefined) {
+        return null;
+    }
+    return Math.max(0, Math.floor(limit));
+}

package/dist/src/common/input.d.ts

@@ -0,0 +1,5 @@
+export type ResolveTextInputOptions = {
+    cwd?: string;
+    encoding?: BufferEncoding;
+};
+export declare function resolveTextInput(input: string, options?: ResolveTextInputOptions): Promise<string>;

package/dist/src/common/input.js

@@ -0,0 +1,25 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+export async function resolveTextInput(input, options = {}) {
+    if (input.includes("\n") || input.includes("\r")) {
+        return input;
+    }
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const inputPath = path.resolve(cwd, input);
+    try {
+        const inputStats = await stat(inputPath);
+        if (!inputStats.isFile()) {
+            throw new Error(`Input path is not a file: ${inputPath}`);
+        }
+        return await readFile(inputPath, options.encoding ?? "utf8");
+    }
+    catch (error) {
+        if (isErrorWithCode(error) && error.code === "ENOENT") {
+            return input;
+        }
+        throw error;
+    }
+}
+function isErrorWithCode(error) {
+    return typeof error === "object" && error !== null && "code" in error;
+}

package/dist/src/nav/declarations.d.ts

@@ -0,0 +1,19 @@
+interface MemberInfo {
+    name: string;
+    signature: string;
+    line: number;
+}
+interface DeclarationInfo {
+    name: string;
+    kind: string;
+    signature: string;
+    line: number;
+    members?: MemberInfo[];
+}
+interface DeclarationsOutput {
+    file: string;
+    declarations: DeclarationInfo[];
+}
+export declare function getDeclarations(filePath: string): DeclarationsOutput;
+export declare const declarationsCommand: import("@stricli/core").Command<import("@stricli/core").CommandContext>;
+export {};

package/dist/src/nav/declarations.js

@@ -0,0 +1,106 @@
+import ts from "typescript";
+import path from "node:path";
+import { buildCommand } from "@stricli/core";
+import { createService, fromPosition, relativePath } from "../service.js";
+function getDeclarationKind(declaration) {
+    if (ts.isFunctionDeclaration(declaration))
+        return "function";
+    if (ts.isClassDeclaration(declaration))
+        return "class";
+    if (ts.isInterfaceDeclaration(declaration))
+        return "interface";
+    if (ts.isTypeAliasDeclaration(declaration))
+        return "type";
+    if (ts.isEnumDeclaration(declaration))
+        return "enum";
+    if (ts.isVariableDeclaration(declaration))
+        return "const";
+    if (ts.isModuleDeclaration(declaration))
+        return "module";
+    return "unknown";
+}
+export function getDeclarations(filePath) {
+    const resolved = path.resolve(filePath);
+    const { program, projectRoot } = createService(process.cwd(), resolved);
+    const sourceFile = program.getSourceFile(resolved);
+    if (!sourceFile) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    const typeChecker = program.getTypeChecker();
+    const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+    if (!moduleSymbol) {
+        return { file: relativePath(projectRoot, resolved), declarations: [] };
+    }
+    const exports = typeChecker.getExportsOfModule(moduleSymbol);
+    const declarations = [];
+    for (const exp of exports) {
+        const decls = exp.getDeclarations();
+        if (!decls || decls.length === 0)
+            continue;
+        const declaration = decls[0];
+        // Only include declarations from the target file
+        if (declaration.getSourceFile().fileName !== resolved)
+            continue;
+        const kind = getDeclarationKind(declaration);
+        const type = (kind === "interface" || kind === "class" || kind === "enum" || kind === "type")
+            ? typeChecker.getDeclaredTypeOfSymbol(exp)
+            : typeChecker.getTypeOfSymbol(exp);
+        const signature = typeChecker.typeToString(type, declaration, ts.TypeFormatFlags.NoTruncation);
+        const pos = fromPosition(sourceFile, declaration.getStart(sourceFile));
+        const info = {
+            name: exp.getName(),
+            kind,
+            signature,
+            line: pos.line,
+        };
+        // For classes and interfaces, enumerate members
+        if (kind === "class" || kind === "interface") {
+            const declType = typeChecker.getDeclaredTypeOfSymbol(exp);
+            const properties = typeChecker.getPropertiesOfType(declType);
+            const members = [];
+            for (const prop of properties) {
+                const propDecls = prop.getDeclarations();
+                if (!propDecls || propDecls.length === 0)
+                    continue;
+                const propDecl = propDecls[0];
+                // Only include members from this file
+                if (propDecl.getSourceFile().fileName !== resolved)
+                    continue;
+                const propType = typeChecker.getTypeOfSymbol(prop);
+                const propSignature = typeChecker.typeToString(propType, propDecl, ts.TypeFormatFlags.NoTruncation);
+                const propPos = fromPosition(sourceFile, propDecl.getStart(sourceFile));
+                members.push({
+                    name: prop.getName(),
+                    signature: propSignature,
+                    line: propPos.line,
+                });
+            }
+            if (members.length > 0) {
+                info.members = members;
+            }
+        }
+        declarations.push(info);
+    }
+    return { file: relativePath(projectRoot, resolved), declarations };
+}
+export const declarationsCommand = buildCommand({
+    func(_flags, file) {
+        const result = getDeclarations(file);
+        this.process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    },
+    parameters: {
+        positional: {
+            kind: "tuple",
+            parameters: [
+                {
+                    brief: "File to list declarations from",
+                    placeholder: "file",
+                    parse: (input) => input,
+                },
+            ],
+        },
+    },
+    docs: {
+        brief: "List exported declarations and type signatures",
+    },
+});

package/dist/src/nav/definition.d.ts

@@ -0,0 +1,14 @@
+interface DefinitionLocation {
+    file: string;
+    line: number;
+    character: number;
+    kind: string;
+    containerName: string;
+}
+interface DefinitionOutput {
+    symbol: string;
+    definitions: DefinitionLocation[];
+}
+export declare function getDefinition(filePath: string, line: number, character: number): DefinitionOutput;
+export declare const definitionCommand: import("@stricli/core").Command<import("@stricli/core").CommandContext>;
+export {};

package/dist/src/nav/definition.js

@@ -0,0 +1,62 @@
+import path from "node:path";
+import { buildCommand } from "@stricli/core";
+import { parseFilePosition } from "./location.js";
+import { createService, toPosition, fromPosition, relativePath } from "../service.js";
+export function getDefinition(filePath, line, character) {
+    const resolved = path.resolve(filePath);
+    const { service, program, projectRoot } = createService(process.cwd(), resolved);
+    const sourceFile = program.getSourceFile(resolved);
+    if (!sourceFile) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    const pos = toPosition(sourceFile, line, character);
+    const defs = service.getDefinitionAtPosition(resolved, pos);
+    if (!defs || defs.length === 0) {
+        // Get the word at position for the symbol name
+        const wordRange = service.getSmartSelectionRange(resolved, pos);
+        const symbolName = wordRange
+            ? sourceFile.text.slice(wordRange.textSpan.start, wordRange.textSpan.start + wordRange.textSpan.length)
+            : "<unknown>";
+        return { symbol: symbolName, definitions: [] };
+    }
+    const symbol = defs[0].name || "<unknown>";
+    const definitions = defs.map((def) => {
+        const defSourceFile = program.getSourceFile(def.fileName);
+        let defLine = 1;
+        let defChar = 1;
+        if (defSourceFile) {
+            const lc = fromPosition(defSourceFile, def.textSpan.start);
+            defLine = lc.line;
+            defChar = lc.character;
+        }
+        return {
+            file: relativePath(projectRoot, def.fileName),
+            line: defLine,
+            character: defChar,
+            kind: def.kind,
+            containerName: def.containerName || "",
+        };
+    });
+    return { symbol, definitions };
+}
+export const definitionCommand = buildCommand({
+    func(_flags, location) {
+        const result = getDefinition(location.file, location.line, location.character);
+        this.process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    },
+    parameters: {
+        positional: {
+            kind: "tuple",
+            parameters: [
+                {
+                    brief: "Location (<file>:<line>:<character>)",
+                    placeholder: "location",
+                    parse: parseFilePosition,
+                },
+            ],
+        },
+    },
+    docs: {
+        brief: "Go to definition at position",
+    },
+});

package/dist/src/nav/location.d.ts

@@ -0,0 +1,6 @@
+export type FilePosition = {
+    file: string;
+    line: number;
+    character: number;
+};
+export declare function parseFilePosition(input: string): FilePosition;

package/dist/src/nav/location.js

@@ -0,0 +1,35 @@
+import { eof, map, regex as parseRegex, seq, str, } from "@claudiu-ceia/combine";
+const LOCATION_ERROR_MESSAGE = "Invalid location: expected <file>:<line>:<character>.";
+const positiveIntegerParser = parseRegex(/[1-9][0-9]*/, "positive integer");
+const fileForColonSyntaxParser = parseRegex(/[^\n]+(?=:[1-9][0-9]*:[1-9][0-9]*$)/, "file path");
+const colonFilePositionParser = map(seq(fileForColonSyntaxParser, str(":"), positiveIntegerParser, str(":"), positiveIntegerParser, eof()), ([file, , line, , character]) => ({
+    file: file.trim(),
+    line: parsePositiveInteger(line, "line"),
+    character: parsePositiveInteger(character, "character"),
+}));
+export function parseFilePosition(input) {
+    const raw = input.trim();
+    if (raw.length === 0) {
+        throw new Error(LOCATION_ERROR_MESSAGE);
+    }
+    const parsed = colonFilePositionParser({ text: raw, index: 0 });
+    if (!parsed.success) {
+        throw new Error(LOCATION_ERROR_MESSAGE);
+    }
+    const file = parsed.value.file.trim();
+    if (file.length === 0) {
+        throw new Error("Invalid file: file path cannot be empty.");
+    }
+    return {
+        file,
+        line: parsed.value.line,
+        character: parsed.value.character,
+    };
+}
+function parsePositiveInteger(raw, label) {
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+        throw new Error(`Invalid ${label}: expected a positive integer.`);
+    }
+    return parsed;
+}

package/dist/src/nav/references.d.ts

@@ -0,0 +1,19 @@
+interface ReferenceLocation {
+    file: string;
+    line: number;
+    character: number;
+    isDefinition: boolean;
+    isWriteAccess: boolean;
+}
+interface ReferencesOutput {
+    symbol: string;
+    definition: {
+        file: string;
+        line: number;
+        character: number;
+    } | null;
+    references: ReferenceLocation[];
+}
+export declare function getReferences(filePath: string, line: number, character: number): ReferencesOutput;
+export declare const referencesCommand: import("@stricli/core").Command<import("@stricli/core").CommandContext>;
+export {};

package/dist/src/nav/references.js

@@ -0,0 +1,75 @@
+import path from "node:path";
+import { buildCommand } from "@stricli/core";
+import { parseFilePosition } from "./location.js";
+import { createService, toPosition, fromPosition, relativePath } from "../service.js";
+export function getReferences(filePath, line, character) {
+    const resolved = path.resolve(filePath);
+    const { service, program, projectRoot } = createService(process.cwd(), resolved);
+    const sourceFile = program.getSourceFile(resolved);
+    if (!sourceFile) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    const pos = toPosition(sourceFile, line, character);
+    const refSymbols = service.findReferences(resolved, pos);
+    if (!refSymbols || refSymbols.length === 0) {
+        const wordRange = service.getSmartSelectionRange(resolved, pos);
+        const symbolName = wordRange
+            ? sourceFile.text.slice(wordRange.textSpan.start, wordRange.textSpan.start + wordRange.textSpan.length)
+            : "<unknown>";
+        return { symbol: symbolName, definition: null, references: [] };
+    }
+    const firstGroup = refSymbols[0];
+    const symbol = firstGroup.definition.name || "<unknown>";
+    // Extract definition location
+    const defSpan = firstGroup.definition.textSpan;
+    const defFile = firstGroup.definition.fileName;
+    const defSourceFile = program.getSourceFile(defFile);
+    let definition = null;
+    if (defSourceFile) {
+        const defPos = fromPosition(defSourceFile, defSpan.start);
+        definition = {
+            file: relativePath(projectRoot, defFile),
+            line: defPos.line,
+            character: defPos.character,
+        };
+    }
+    // Extract all references
+    const references = [];
+    for (const group of refSymbols) {
+        for (const ref of group.references) {
+            const refSourceFile = program.getSourceFile(ref.fileName);
+            if (!refSourceFile)
+                continue;
+            const refPos = fromPosition(refSourceFile, ref.textSpan.start);
+            references.push({
+                file: relativePath(projectRoot, ref.fileName),
+                line: refPos.line,
+                character: refPos.character,
+                isDefinition: ref.isDefinition ?? false,
+                isWriteAccess: ref.isWriteAccess ?? false,
+            });
+        }
+    }
+    return { symbol, definition, references };
+}
+export const referencesCommand = buildCommand({
+    func(_flags, location) {
+        const result = getReferences(location.file, location.line, location.character);
+        this.process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    },
+    parameters: {
+        positional: {
+            kind: "tuple",
+            parameters: [
+                {
+                    brief: "Location (<file>:<line>:<character>)",
+                    placeholder: "location",
+                    parse: parseFilePosition,
+                },
+            ],
+        },
+    },
+    docs: {
+        brief: "Find all references at position",
+    },
+});

package/dist/src/patch/patch.d.ts

@@ -0,0 +1,27 @@
+import { type ChalkInstance } from "chalk";
+import type { SpatchOccurrence, SpatchResult } from "../spatch/types.ts";
+export type PatchCommandFlags = {
+    "dry-run"?: boolean;
+    interactive?: boolean;
+    json?: boolean;
+    "no-color"?: boolean;
+    cwd?: string;
+};
+type InteractiveChoice = "yes" | "no" | "all" | "quit";
+export type InteractiveContext = {
+    file: string;
+    occurrence: SpatchOccurrence;
+    changeNumber: number;
+    totalChanges: number;
+};
+export type RunPatchCommandOptions = {
+    interactiveDecider?: (ctx: InteractiveContext) => Promise<InteractiveChoice>;
+};
+export declare function runPatchCommand(patchInput: string, scope: string | undefined, flags: PatchCommandFlags, options?: RunPatchCommandOptions): Promise<SpatchResult>;
+type FormatPatchOutputOptions = {
+    color?: boolean;
+    chalkInstance?: ChalkInstance;
+};
+export declare function formatPatchOutput(result: SpatchResult, options?: FormatPatchOutputOptions): string;
+export declare const patchCommand: import("@stricli/core").Command<import("@stricli/core").CommandContext>;
+export {};