@claudiu-ceia/astkit 0.1.0

package/dist/src/pattern/types.d.ts

@@ -0,0 +1,27 @@
+export type TextToken = {
+    kind: "text";
+    value: string;
+};
+export type EllipsisToken = {
+    kind: "ellipsis";
+    index: number;
+};
+export type HoleToken = {
+    kind: "hole";
+    name: string;
+    anonymous: boolean;
+    constraintSource: string | null;
+    constraintRegex: RegExp | null;
+};
+export type TemplateToken = TextToken | HoleToken | EllipsisToken;
+export type CompiledTemplate = {
+    source: string;
+    tokens: TemplateToken[];
+};
+export type TemplateMatch = {
+    start: number;
+    end: number;
+    text: string;
+    captures: Record<string, string>;
+};
+export declare const ELLIPSIS_CAPTURE_PREFIX = "__ellipsis_";

package/dist/src/pattern/types.js

@@ -0,0 +1 @@
+export const ELLIPSIS_CAPTURE_PREFIX = "__ellipsis_";

package/dist/src/search/search.d.ts

@@ -0,0 +1,16 @@
+import { type ChalkInstance } from "chalk";
+import type { SgrepResult } from "../sgrep/types.ts";
+export type SearchCommandFlags = {
+    cwd?: string;
+    "no-isomorphisms"?: boolean;
+    "no-color"?: boolean;
+    json?: boolean;
+};
+export declare function runSearchCommand(patternInput: string, scope: string | undefined, flags: SearchCommandFlags): Promise<SgrepResult>;
+type FormatSearchOutputOptions = {
+    color?: boolean;
+    chalkInstance?: ChalkInstance;
+};
+export declare function formatSearchOutput(result: SgrepResult, options?: FormatSearchOutputOptions): string;
+export declare const searchCommand: import("@stricli/core").Command<import("@stricli/core").CommandContext>;
+export {};

package/dist/src/search/search.js

@@ -0,0 +1,207 @@
+import { buildCommand } from "@stricli/core";
+import chalk, { Chalk } from "chalk";
+import { searchProject } from "../sgrep/sgrep.js";
+export async function runSearchCommand(patternInput, scope, flags) {
+    return searchProject(patternInput, {
+        cwd: flags.cwd,
+        isomorphisms: !(flags["no-isomorphisms"] ?? false),
+        scope: scope ?? ".",
+    });
+}
+export function formatSearchOutput(result, options = {}) {
+    if (result.files.length === 0) {
+        return "";
+    }
+    const chalkInstance = buildChalk(options);
+    const useColor = chalkInstance.level > 0;
+    const captureColorMap = useColor
+        ? buildCaptureColorMap(result)
+        : new Map();
+    const lines = [];
+    for (const file of result.files) {
+        lines.push(useColor ? chalkInstance.gray(`//${file.file}`) : `//${file.file}`);
+        for (const match of file.matches) {
+            const preview = buildMatchPreview(match.matched);
+            const linePrefix = useColor
+                ? chalkInstance.gray(`${match.line}: `)
+                : `${match.line}: `;
+            const highlightedPreview = useColor
+                ? highlightCaptures(preview.text, match.captures, chalkInstance, captureColorMap)
+                : preview.text;
+            const previewSuffix = preview.truncated
+                ? useColor
+                    ? chalkInstance.gray(" ...")
+                    : " ..."
+                : "";
+            lines.push(`${linePrefix}${highlightedPreview}${previewSuffix}`);
+        }
+    }
+    return lines.join("\n");
+}
+function buildMatchPreview(matchedText) {
+    const normalized = matchedText.replaceAll("\r\n", "\n");
+    const firstLine = normalized.split("\n")[0] ?? "";
+    return {
+        text: firstLine,
+        truncated: normalized.includes("\n"),
+    };
+}
+function buildChalk(options) {
+    if (options.chalkInstance) {
+        return options.chalkInstance;
+    }
+    const shouldColor = options.color ?? false;
+    if (!shouldColor) {
+        return new Chalk({ level: 0 });
+    }
+    const level = chalk.level > 0 ? chalk.level : 1;
+    return new Chalk({ level });
+}
+function highlightCaptures(preview, captures, chalkInstance, captureColorMap) {
+    if (preview.length === 0) {
+        return preview;
+    }
+    const colorPalette = [
+        chalkInstance.cyan,
+        chalkInstance.green,
+        chalkInstance.yellow,
+        chalkInstance.magenta,
+        chalkInstance.blue,
+        chalkInstance.red,
+    ];
+    const captureEntries = Object.entries(captures)
+        .map(([name, value]) => [name, toPreviewSearchValue(value)])
+        .filter(([name, value]) => name.length > 0 && value.length > 0);
+    if (captureEntries.length === 0) {
+        return preview;
+    }
+    const ranges = [];
+    const sortedEntries = [...captureEntries].sort((left, right) => right[1].length - left[1].length || left[0].localeCompare(right[0]));
+    for (let entryIndex = 0; entryIndex < sortedEntries.length; entryIndex += 1) {
+        const [name, value] = sortedEntries[entryIndex];
+        const colorIndex = captureColorMap.get(name) ?? (entryIndex % colorPalette.length);
+        let fromIndex = 0;
+        while (fromIndex < preview.length) {
+            const matchIndex = preview.indexOf(value, fromIndex);
+            if (matchIndex < 0) {
+                break;
+            }
+            const matchEnd = matchIndex + value.length;
+            const overlaps = ranges.some((range) => matchIndex < range.end && range.start < matchEnd);
+            if (!overlaps) {
+                ranges.push({
+                    start: matchIndex,
+                    end: matchEnd,
+                    colorIndex,
+                });
+            }
+            fromIndex = matchIndex + value.length;
+        }
+    }
+    if (ranges.length === 0) {
+        return preview;
+    }
+    ranges.sort((left, right) => left.start - right.start);
+    const parts = [];
+    let cursor = 0;
+    for (const range of ranges) {
+        if (range.start > cursor) {
+            parts.push(preview.slice(cursor, range.start));
+        }
+        const colorize = colorPalette[range.colorIndex] ?? chalkInstance.white;
+        parts.push(colorize(preview.slice(range.start, range.end)));
+        cursor = range.end;
+    }
+    if (cursor < preview.length) {
+        parts.push(preview.slice(cursor));
+    }
+    return parts.join("");
+}
+function toPreviewSearchValue(rawValue) {
+    const normalized = rawValue.replaceAll("\r\n", "\n");
+    return normalized.split("\n")[0] ?? "";
+}
+function buildCaptureColorMap(result) {
+    const captureNames = [];
+    const seen = new Set();
+    for (const file of result.files) {
+        for (const match of file.matches) {
+            for (const name of Object.keys(match.captures)) {
+                if (seen.has(name)) {
+                    continue;
+                }
+                seen.add(name);
+                captureNames.push(name);
+            }
+        }
+    }
+    captureNames.sort((left, right) => left.localeCompare(right));
+    const captureColorMap = new Map();
+    for (let index = 0; index < captureNames.length; index += 1) {
+        const name = captureNames[index];
+        if (name) {
+            captureColorMap.set(name, index);
+        }
+    }
+    return captureColorMap;
+}
+export const searchCommand = buildCommand({
+    async func(flags, patternInput, scope) {
+        const result = await runSearchCommand(patternInput, scope, flags);
+        if (flags.json ?? false) {
+            this.process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+            return;
+        }
+        const output = formatSearchOutput(result, {
+            color: Boolean(process.stdout.isTTY) && !(flags["no-color"] ?? false),
+        });
+        if (output.length > 0) {
+            this.process.stdout.write(`${output}\n`);
+        }
+    },
+    parameters: {
+        flags: {
+            json: {
+                kind: "boolean",
+                optional: true,
+                brief: "Output structured JSON instead of compact text",
+            },
+            "no-color": {
+                kind: "boolean",
+                optional: true,
+                brief: "Disable colored output",
+            },
+            "no-isomorphisms": {
+                kind: "boolean",
+                optional: true,
+                brief: "Disable isomorphism expansion during matching",
+            },
+            cwd: {
+                kind: "parsed",
+                optional: true,
+                brief: "Working directory for resolving pattern file and scope",
+                placeholder: "path",
+                parse: (input) => input,
+            },
+        },
+        positional: {
+            kind: "tuple",
+            parameters: [
+                {
+                    brief: "Pattern text or path to pattern file",
+                    placeholder: "pattern",
+                    parse: (input) => input,
+                },
+                {
+                    brief: "Scope file or directory (defaults to current directory)",
+                    placeholder: "scope",
+                    parse: (input) => input,
+                    optional: true,
+                },
+            ],
+        },
+    },
+    docs: {
+        brief: "Run structural search (sgrep-style) from a pattern",
+    },
+});

package/dist/src/service.d.ts

@@ -0,0 +1,16 @@
+import ts from "typescript";
+export interface Service {
+    service: ts.LanguageService;
+    program: ts.Program;
+    projectRoot: string;
+}
+export declare function createService(projectDir: string, targetFile?: string | readonly string[]): Service;
+/** Convert 1-indexed line:character to 0-indexed offset */
+export declare function toPosition(sourceFile: ts.SourceFile, line: number, character: number): number;
+/** Convert 0-indexed offset to 1-indexed { line, character } */
+export declare function fromPosition(sourceFile: ts.SourceFile, offset: number): {
+    line: number;
+    character: number;
+};
+/** Get relative path from project root */
+export declare function relativePath(projectRoot: string, filePath: string): string;

package/dist/src/service.js

@@ -0,0 +1,72 @@
+import ts from "typescript";
+import path from "node:path";
+export function createService(projectDir, targetFile) {
+    const configPath = ts.findConfigFile(projectDir, ts.sys.fileExists);
+    let compilerOptions;
+    let fileNames;
+    let projectRoot;
+    if (configPath) {
+        const { config, error } = ts.readConfigFile(configPath, ts.sys.readFile);
+        if (error) {
+            throw new Error(`Failed to read tsconfig: ${ts.flattenDiagnosticMessageText(error.messageText, "\n")}`);
+        }
+        projectRoot = path.dirname(configPath);
+        const parsed = ts.parseJsonConfigFileContent(config, ts.sys, projectRoot);
+        compilerOptions = parsed.options;
+        fileNames = parsed.fileNames;
+    }
+    else {
+        compilerOptions = ts.getDefaultCompilerOptions();
+        fileNames = [];
+        projectRoot = projectDir;
+    }
+    // Ensure requested target files are in the language-service file set.
+    const targetFiles = normalizeTargetFiles(targetFile);
+    for (const requestedFile of targetFiles) {
+        const resolved = path.resolve(requestedFile);
+        if (!fileNames.includes(resolved)) {
+            fileNames.push(resolved);
+        }
+    }
+    const host = {
+        getScriptFileNames: () => fileNames,
+        getScriptVersion: () => "0",
+        getScriptSnapshot: (file) => {
+            const content = ts.sys.readFile(file);
+            if (content === undefined)
+                return undefined;
+            return ts.ScriptSnapshot.fromString(content);
+        },
+        getCurrentDirectory: () => projectRoot,
+        getCompilationSettings: () => compilerOptions,
+        getDefaultLibFileName: ts.getDefaultLibFilePath,
+        fileExists: ts.sys.fileExists,
+        readFile: ts.sys.readFile,
+        readDirectory: ts.sys.readDirectory,
+    };
+    const service = ts.createLanguageService(host);
+    const program = service.getProgram();
+    return { service, program, projectRoot };
+}
+function normalizeTargetFiles(targetFile) {
+    if (targetFile === undefined) {
+        return [];
+    }
+    if (typeof targetFile === "string") {
+        return [targetFile];
+    }
+    return [...targetFile];
+}
+/** Convert 1-indexed line:character to 0-indexed offset */
+export function toPosition(sourceFile, line, character) {
+    return sourceFile.getPositionOfLineAndCharacter(line - 1, character - 1);
+}
+/** Convert 0-indexed offset to 1-indexed { line, character } */
+export function fromPosition(sourceFile, offset) {
+    const lc = sourceFile.getLineAndCharacterOfPosition(offset);
+    return { line: lc.line + 1, character: lc.character + 1 };
+}
+/** Get relative path from project root */
+export function relativePath(projectRoot, filePath) {
+    return path.relative(projectRoot, filePath);
+}

package/dist/src/sgrep/index.d.ts

@@ -0,0 +1,5 @@
+export { searchProject, sgrep, } from "./sgrep.ts";
+export type { SgrepFileResult, SgrepMatch, SgrepOptions, SgrepResult, } from "./types.ts";
+export { DEFAULT_SEARCHABLE_EXTENSIONS, DEFAULT_SEARCH_EXCLUDED_DIRECTORIES, } from "./types.ts";
+export { DEFAULT_ISOMORPHISM_RULES, expandPatternIsomorphisms, } from "./isomorphisms/index.ts";
+export type { ExpandIsomorphismsOptions, IsomorphismRule, } from "./isomorphisms/index.ts";

package/dist/src/sgrep/index.js

@@ -0,0 +1,3 @@
+export { searchProject, sgrep, } from "./sgrep.js";
+export { DEFAULT_SEARCHABLE_EXTENSIONS, DEFAULT_SEARCH_EXCLUDED_DIRECTORIES, } from "./types.js";
+export { DEFAULT_ISOMORPHISM_RULES, expandPatternIsomorphisms, } from "./isomorphisms/index.js";

package/dist/src/sgrep/isomorphisms/expand.d.ts

@@ -0,0 +1,2 @@
+import type { ExpandIsomorphismsOptions } from "./types.ts";
+export declare function expandPatternIsomorphisms(pattern: string, options?: ExpandIsomorphismsOptions): string[];

package/dist/src/sgrep/isomorphisms/expand.js

@@ -0,0 +1,51 @@
+import { DEFAULT_ISOMORPHISM_RULES } from "./registry.js";
+import { parseTemplateIsomorphismContext } from "./template-ast.js";
+const DEFAULT_MAX_ISOMORPHISM_VARIANTS = 24;
+export function expandPatternIsomorphisms(pattern, options = {}) {
+    if (!(options.enabled ?? true)) {
+        return [pattern];
+    }
+    const rules = options.rules ?? DEFAULT_ISOMORPHISM_RULES;
+    if (rules.length === 0) {
+        return [pattern];
+    }
+    const maxVariants = normalizeMaxVariants(options.maxVariants);
+    const variants = [{ pattern, applied: [] }];
+    const seenPatterns = new Set([pattern]);
+    for (let variantIndex = 0; variantIndex < variants.length && variants.length < maxVariants; variantIndex += 1) {
+        const current = variants[variantIndex];
+        if (!current) {
+            continue;
+        }
+        const context = parseTemplateIsomorphismContext(current.pattern);
+        if (!context) {
+            continue;
+        }
+        for (const rule of rules) {
+            const produced = rule.apply(context);
+            for (const nextPattern of produced) {
+                if (seenPatterns.has(nextPattern)) {
+                    continue;
+                }
+                seenPatterns.add(nextPattern);
+                variants.push({
+                    pattern: nextPattern,
+                    applied: [...current.applied, rule.id],
+                });
+                if (variants.length >= maxVariants) {
+                    break;
+                }
+            }
+            if (variants.length >= maxVariants) {
+                break;
+            }
+        }
+    }
+    return variants.map((variant) => variant.pattern);
+}
+function normalizeMaxVariants(maxVariants) {
+    if (maxVariants === undefined) {
+        return DEFAULT_MAX_ISOMORPHISM_VARIANTS;
+    }
+    return Math.max(1, Math.floor(maxVariants));
+}

package/dist/src/sgrep/isomorphisms/index.d.ts

@@ -0,0 +1,3 @@
+export { expandPatternIsomorphisms } from "./expand.ts";
+export { DEFAULT_ISOMORPHISM_RULES } from "./registry.ts";
+export type { ExpandIsomorphismsOptions, IsomorphismRule } from "./types.ts";

package/dist/src/sgrep/isomorphisms/index.js

@@ -0,0 +1,2 @@
+export { expandPatternIsomorphisms } from "./expand.js";
+export { DEFAULT_ISOMORPHISM_RULES } from "./registry.js";

package/dist/src/sgrep/isomorphisms/registry.d.ts

@@ -0,0 +1,2 @@
+import type { IsomorphismRule } from "./types.ts";
+export declare const DEFAULT_ISOMORPHISM_RULES: readonly IsomorphismRule[];

package/dist/src/sgrep/isomorphisms/registry.js

@@ -0,0 +1,8 @@
+import { commutativeBinaryRule } from "./rules/commutative-binary.js";
+import { objectLiteralPropertyOrderRule } from "./rules/object-literal-property-order.js";
+import { redundantParenthesesRule } from "./rules/redundant-parentheses.js";
+export const DEFAULT_ISOMORPHISM_RULES = [
+    commutativeBinaryRule,
+    objectLiteralPropertyOrderRule,
+    redundantParenthesesRule,
+];

package/dist/src/sgrep/isomorphisms/rules/commutative-binary.d.ts

@@ -0,0 +1,2 @@
+import type { IsomorphismRule } from "../types.ts";
+export declare const commutativeBinaryRule: IsomorphismRule;

package/dist/src/sgrep/isomorphisms/rules/commutative-binary.js

@@ -0,0 +1,51 @@
+import ts from "typescript";
+const COMMUTATIVE_OPERATOR_KINDS = new Set([
+    ts.SyntaxKind.PlusToken,
+    ts.SyntaxKind.AsteriskToken,
+    ts.SyntaxKind.AmpersandToken,
+    ts.SyntaxKind.BarToken,
+    ts.SyntaxKind.CaretToken,
+    ts.SyntaxKind.EqualsEqualsToken,
+    ts.SyntaxKind.EqualsEqualsEqualsToken,
+    ts.SyntaxKind.ExclamationEqualsToken,
+    ts.SyntaxKind.ExclamationEqualsEqualsToken,
+]);
+export const commutativeBinaryRule = {
+    id: "commutative-binary",
+    description: "Swap operands of commutative binary operators.",
+    apply: (context) => {
+        const variants = new Set();
+        visitNode(context.ast, (node) => {
+            if (!ts.isBinaryExpression(node)) {
+                return;
+            }
+            if (!COMMUTATIVE_OPERATOR_KINDS.has(node.operatorToken.kind)) {
+                return;
+            }
+            const expressionStart = node.getStart(context.ast);
+            const expressionEnd = node.end;
+            const leftStart = node.left.getStart(context.ast);
+            const leftEnd = node.left.end;
+            const rightStart = node.right.getStart(context.ast);
+            const rightEnd = node.right.end;
+            const leftText = context.source.slice(leftStart, leftEnd);
+            const middleText = context.source.slice(leftEnd, rightStart);
+            const rightText = context.source.slice(rightStart, rightEnd);
+            if (leftText.length === 0 || middleText.length === 0 || rightText.length === 0) {
+                return;
+            }
+            const swappedExpression = `${rightText}${middleText}${leftText}`;
+            const variant = context.source.slice(0, expressionStart) +
+                swappedExpression +
+                context.source.slice(expressionEnd);
+            if (variant !== context.source) {
+                variants.add(variant);
+            }
+        });
+        return [...variants];
+    },
+};
+function visitNode(node, visitor) {
+    visitor(node);
+    ts.forEachChild(node, (child) => visitNode(child, visitor));
+}

package/dist/src/sgrep/isomorphisms/rules/object-literal-property-order.d.ts

@@ -0,0 +1,2 @@
+import type { IsomorphismRule } from "../types.ts";
+export declare const objectLiteralPropertyOrderRule: IsomorphismRule;

package/dist/src/sgrep/isomorphisms/rules/object-literal-property-order.js

@@ -0,0 +1,82 @@
+import ts from "typescript";
+export const objectLiteralPropertyOrderRule = {
+    id: "object-literal-property-order",
+    description: "Swap adjacent object literal entries where key/value order is semantically irrelevant.",
+    apply: (context) => {
+        const variants = new Set();
+        visitNode(context.ast, (node) => {
+            if (!ts.isObjectLiteralExpression(node)) {
+                return;
+            }
+            const properties = [...node.properties];
+            if (properties.length < 2) {
+                return;
+            }
+            if (!isReorderableMapObject(properties)) {
+                return;
+            }
+            for (let index = 0; index < properties.length - 1; index += 1) {
+                const left = properties[index];
+                const right = properties[index + 1];
+                if (!left || !right) {
+                    continue;
+                }
+                const leftStart = left.getStart(context.ast);
+                const leftEnd = left.end;
+                const rightStart = right.getStart(context.ast);
+                const rightEnd = right.end;
+                if (leftEnd > rightStart) {
+                    continue;
+                }
+                const separator = context.source.slice(leftEnd, rightStart);
+                if (!separator.includes(",")) {
+                    continue;
+                }
+                const swappedSegment = context.source.slice(rightStart, rightEnd) +
+                    separator +
+                    context.source.slice(leftStart, leftEnd);
+                const variant = context.source.slice(0, leftStart) +
+                    swappedSegment +
+                    context.source.slice(rightEnd);
+                if (variant !== context.source) {
+                    variants.add(variant);
+                }
+            }
+        });
+        return [...variants];
+    },
+};
+function isReorderableMapObject(properties) {
+    const seenKeys = new Set();
+    for (const property of properties) {
+        if (!ts.isPropertyAssignment(property) &&
+            !ts.isShorthandPropertyAssignment(property)) {
+            return false;
+        }
+        const key = getStablePropertyKey(property.name);
+        if (key === null) {
+            return false;
+        }
+        if (seenKeys.has(key)) {
+            // Duplicate keys are order-sensitive ("last write wins").
+            return false;
+        }
+        seenKeys.add(key);
+    }
+    return true;
+}
+function getStablePropertyKey(name) {
+    if (ts.isIdentifier(name)) {
+        return name.text;
+    }
+    if (ts.isStringLiteral(name) ||
+        ts.isNumericLiteral(name) ||
+        ts.isNoSubstitutionTemplateLiteral(name)) {
+        return name.text;
+    }
+    return null;
+}
+function visitNode(node, visitor) {
+    visitor(node);
+    ts.forEachChild(node, (child) => visitNode(child, visitor));
+}

package/dist/src/sgrep/isomorphisms/rules/redundant-parentheses.d.ts

@@ -0,0 +1,2 @@
+import type { IsomorphismRule } from "../types.ts";
+export declare const redundantParenthesesRule: IsomorphismRule;

package/dist/src/sgrep/isomorphisms/rules/redundant-parentheses.js

@@ -0,0 +1,43 @@
+import ts from "typescript";
+export const redundantParenthesesRule = {
+    id: "redundant-parentheses",
+    description: "Add or remove extra parentheses around binary expressions.",
+    apply: (context) => {
+        const variants = new Set();
+        visitNode(context.ast, (node) => {
+            if (ts.isParenthesizedExpression(node)) {
+                const start = node.getStart(context.ast);
+                const end = node.end;
+                const innerStart = node.expression.getStart(context.ast);
+                const innerEnd = node.expression.end;
+                const innerText = context.source.slice(innerStart, innerEnd);
+                if (innerText.length > 0) {
+                    const variant = context.source.slice(0, start) +
+                        innerText +
+                        context.source.slice(end);
+                    if (variant !== context.source) {
+                        variants.add(variant);
+                    }
+                }
+            }
+            if (ts.isBinaryExpression(node)) {
+                const start = node.getStart(context.ast);
+                const end = node.end;
+                const expressionText = context.source.slice(start, end);
+                if (expressionText.length > 0) {
+                    const variant = context.source.slice(0, start) +
+                        `(${expressionText})` +
+                        context.source.slice(end);
+                    if (variant !== context.source) {
+                        variants.add(variant);
+                    }
+                }
+            }
+        });
+        return [...variants];
+    },
+};
+function visitNode(node, visitor) {
+    visitor(node);
+    ts.forEachChild(node, (child) => visitNode(child, visitor));
+}

package/dist/src/sgrep/isomorphisms/template-ast.d.ts

@@ -0,0 +1,2 @@
+import type { IsomorphismContext } from "./types.ts";
+export declare function parseTemplateIsomorphismContext(source: string): IsomorphismContext | null;