contextdiet-cli 0.1.0

package/dist/core/pruner/index.js

@@ -0,0 +1,56 @@
+/**
+ * AstPruner (Task 3.5).
+ *
+ * Reconstructs a file down to just the symbols the Selector kept, plus the
+ * imports those symbols still reference. Strategy:
+ *
+ *   1. Parse top-level symbols and whole import statements.
+ *   2. Keep the symbols whose names are in the keep-set.
+ *   3. Find which identifiers the kept symbols reference, and keep only the
+ *      import statements that introduce at least one referenced binding
+ *      (dead-import elimination).
+ *   4. Re-emit kept imports + kept symbols in original source order, each sliced
+ *      verbatim via `Parser.sliceNode`.
+ *
+ * Because it only ever *omits* whole declarations and re-emits kept ones
+ * unchanged, the pruner cannot introduce a syntax error into what it emits.
+ */
+import { AstGrepperParser } from '../parser/index.js';
+export class AstPruner {
+    parser;
+    constructor(parser = new AstGrepperParser()) {
+        this.parser = parser;
+    }
+    async prune(source, filePath, keep) {
+        const symbols = await this.parser.extractSymbols(source, filePath);
+        const keptSymbols = symbols.filter((symbol) => keep.has(symbol.name));
+        if (keptSymbols.length === 0)
+            return '';
+        // Which imports do the survivors still use?
+        const referenced = await this.parser.collectReferences(source, filePath, keptSymbols.map((symbol) => symbol.range));
+        const importStatements = await this.parser.extractImportStatements(source, filePath);
+        const keptImports = importStatements.filter((statement) => statement.localNames.some((name) => referenced.has(name)));
+        // Emit imports then symbols, in original source order, de-duplicating ranges
+        // (a multi-binding declaration like `const a = 1, b = 2` yields one range for
+        // several kept symbols and must be sliced exactly once).
+        const ranges = dedupeRanges([
+            ...keptImports.map((statement) => statement.range),
+            ...keptSymbols.map((symbol) => symbol.range),
+        ]).sort((a, b) => a.start.index - b.start.index);
+        return ranges.map((range) => this.parser.sliceNode(source, range)).join('\n\n') + '\n';
+    }
+}
+/** Remove ranges that cover the exact same span. */
+function dedupeRanges(ranges) {
+    const seen = new Set();
+    const unique = [];
+    for (const range of ranges) {
+        const key = `${range.start.index}:${range.end.index}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push(range);
+    }
+    return unique;
+}
+//# sourceMappingURL=index.js.map

package/dist/core/pruner/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/pruner/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAItD,MAAM,OAAO,SAAS;IACH,MAAM,CAAS;IAEhC,YAAY,MAAM,GAAW,IAAI,gBAAgB,EAAE;QACjD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,MAAc,EAAE,QAAgB,EAAE,IAAyB;QACrE,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QACnE,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;QACtE,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,EAAE,CAAC;QAExC,4CAA4C;QAC5C,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,iBAAiB,CACpD,MAAM,EACN,QAAQ,EACR,WAAW,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAC1C,CAAC;QACF,MAAM,gBAAgB,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,uBAAuB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QACrF,MAAM,WAAW,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CACxD,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAC1D,CAAC;QAEF,6EAA6E;QAC7E,8EAA8E;QAC9E,yDAAyD;QACzD,MAAM,MAAM,GAAG,YAAY,CAAC;YAC1B,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC;YAClD,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC;SAC7C,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAEjD,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;IACzF,CAAC;CACF;AAED,oDAAoD;AACpD,SAAS,YAAY,CAAC,MAAwB;IAC5C,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,MAAM,GAAY,EAAE,CAAC;IAC3B,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,GAAG,GAAG,GAAG,KAAK,CAAC,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC;QACtD,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,SAAS;QAC5B,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACd,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACrB,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/core/pruner/types.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Pruner contract for ContextDiet (Task 3.5).
+ *
+ * The pruner is the last transform before bundling: given a single file's source
+ * and the set of symbol names the Selector chose to keep, it reconstructs a
+ * trimmed version of that file containing only those symbols and the imports they
+ * still use. It never rewrites code — it re-emits kept declarations verbatim — so
+ * emitted output is syntactically valid by construction.
+ */
+export interface Pruner {
+    /**
+     * Reconstruct `source` keeping only the top-level symbols named in `keep`,
+     * plus the import statements those surviving symbols reference. Returns the
+     * empty string when nothing is kept.
+     */
+    prune(source: string, filePath: string, keep: ReadonlySet<string>): Promise<string>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/pruner/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/pruner/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,WAAW,MAAM;IACrB;;;;OAIG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACrF"}

package/dist/core/pruner/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/pruner/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/core/pruner/types.ts"],"names":[],"mappings":""}

package/dist/core/ranker/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * LexicalRanker — Task 3.0.
+ *
+ * A lightweight, deterministic, $0 matching engine. It turns a natural-language
+ * focus string into a set of seed symbols by pure string analysis: tokenize the
+ * query (dropping stop words), tokenize each symbol name (splitting camelCase /
+ * snake_case), and score the overlap. No embeddings, no API, no network, no I/O.
+ *
+ * Scoring is intentionally simple and explainable:
+ *   - An *exact* query-token ↔ symbol-token match is worth the most.
+ *   - A *partial* (substring) match is worth a fraction of that.
+ *   - Earlier query tokens weigh slightly more (users front-load intent, e.g.
+ *     "JWT" in "Fix JWT auth"), which lets `verifyJWT` outrank `authMiddleware`.
+ *   - The per-symbol raw score is squashed into `[0, 1]` so weights are stable
+ *     regardless of query length.
+ */
+import type { SymbolNode } from '../parser/types.js';
+import type { Ranker, RankerOptions, SeedNode } from './types.js';
+export declare class LexicalRanker implements Ranker {
+    private readonly minWeight;
+    private readonly limit;
+    constructor(options?: RankerOptions);
+    tokenize(focusQuery: string): string[];
+    determineSeeds(focusQuery: string, allSymbols: readonly SymbolNode[]): SeedNode[];
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/core/ranker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/ranker/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AA0BlE,qBAAa,aAAc,YAAW,MAAM;IAC1C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;IAE3C,YAAY,OAAO,GAAE,aAAkB,EAGtC;IAED,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAarC;IAED,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,UAAU,EAAE,GAAG,QAAQ,EAAE,CAqChF;CACF"}

package/dist/core/ranker/index.js

@@ -0,0 +1,149 @@
+/**
+ * LexicalRanker — Task 3.0.
+ *
+ * A lightweight, deterministic, $0 matching engine. It turns a natural-language
+ * focus string into a set of seed symbols by pure string analysis: tokenize the
+ * query (dropping stop words), tokenize each symbol name (splitting camelCase /
+ * snake_case), and score the overlap. No embeddings, no API, no network, no I/O.
+ *
+ * Scoring is intentionally simple and explainable:
+ *   - An *exact* query-token ↔ symbol-token match is worth the most.
+ *   - A *partial* (substring) match is worth a fraction of that.
+ *   - Earlier query tokens weigh slightly more (users front-load intent, e.g.
+ *     "JWT" in "Fix JWT auth"), which lets `verifyJWT` outrank `authMiddleware`.
+ *   - The per-symbol raw score is squashed into `[0, 1]` so weights are stable
+ *     regardless of query length.
+ */
+/**
+ * Common English filler plus task-verb noise that carries no signal about which
+ * code symbol matters. Kept deliberately small and hand-audited — over-stemming
+ * hurts precision more than a few extra stop words help.
+ */
+const STOP_WORDS = new Set([
+    // articles / conjunctions / prepositions
+    'a', 'an', 'the', 'and', 'or', 'but', 'of', 'to', 'in', 'on', 'at', 'for',
+    'with', 'from', 'into', 'by', 'as', 'is', 'are', 'be', 'this', 'that', 'it',
+    // generic task verbs / nouns that describe the *action*, not the *subject*
+    'fix', 'fixing', 'fixed', 'bug', 'bugs', 'issue', 'issues', 'error', 'errors',
+    'add', 'adding', 'update', 'updating', 'change', 'changing', 'refactor',
+    'implement', 'handle', 'support', 'make', 'please', 'need', 'want', 'should',
+]);
+/** Weight of an exact token match vs. a partial (substring) match. */
+const EXACT_MATCH_SCORE = 1;
+const PARTIAL_MATCH_SCORE = 0.4;
+/** How strongly earlier query tokens are favored (0 = no positional bias). */
+const POSITION_DECAY = 0.15;
+const DEFAULT_MIN_WEIGHT = 0;
+export class LexicalRanker {
+    minWeight;
+    limit;
+    constructor(options = {}) {
+        this.minWeight = options.minWeight ?? DEFAULT_MIN_WEIGHT;
+        this.limit = options.limit;
+    }
+    tokenize(focusQuery) {
+        const seen = new Set();
+        const tokens = [];
+        for (const raw of splitWords(focusQuery)) {
+            const token = raw.toLowerCase();
+            if (token.length === 0 || STOP_WORDS.has(token))
+                continue;
+            if (seen.has(token))
+                continue;
+            seen.add(token);
+            tokens.push(token);
+        }
+        return tokens;
+    }
+    determineSeeds(focusQuery, allSymbols) {
+        const queryTokens = this.tokenize(focusQuery);
+        if (queryTokens.length === 0)
+            return [];
+        // Positional weight: token 0 gets 1.0, each subsequent token slightly less.
+        // Normalized by the max so a single-token query still tops out at 1.0.
+        const positionWeights = queryTokens.map((_, i) => 1 / (1 + POSITION_DECAY * i));
+        const maxPossible = positionWeights.reduce((sum, w) => sum + w * EXACT_MATCH_SCORE, 0);
+        const seeds = [];
+        for (const symbol of allSymbols) {
+            const symbolTokens = tokenizeIdentifier(symbol.name);
+            if (symbolTokens.length === 0)
+                continue;
+            let raw = 0;
+            const matchedTokens = [];
+            queryTokens.forEach((queryToken, i) => {
+                const contribution = bestTokenMatch(queryToken, symbolTokens);
+                if (contribution > 0) {
+                    raw += contribution * positionWeights[i];
+                    matchedTokens.push(queryToken);
+                }
+            });
+            if (raw <= 0)
+                continue;
+            const weight = clamp01(raw / maxPossible);
+            if (weight <= this.minWeight)
+                continue;
+            seeds.push({ symbol, weight, matchedTokens });
+        }
+        seeds.sort(byWeightThenName);
+        return this.limit === undefined ? seeds : seeds.slice(0, this.limit);
+    }
+}
+/**
+ * Best score for a single query token against all tokens of one symbol:
+ * a full exact match if any symbol token equals it, otherwise the best
+ * substring (partial) match, otherwise zero.
+ */
+function bestTokenMatch(queryToken, symbolTokens) {
+    let best = 0;
+    for (const symbolToken of symbolTokens) {
+        if (symbolToken === queryToken) {
+            return EXACT_MATCH_SCORE; // can't beat exact — short-circuit
+        }
+        if (symbolToken.includes(queryToken) || queryToken.includes(symbolToken)) {
+            best = Math.max(best, PARTIAL_MATCH_SCORE);
+        }
+    }
+    return best;
+}
+/** Split a free-text query into raw word chunks on any non-alphanumeric run. */
+function splitWords(text) {
+    return text.split(/[^A-Za-z0-9]+/).filter((w) => w.length > 0);
+}
+/**
+ * Break a code identifier into lowercase lexical tokens, understanding the
+ * conventions the parser emits: camelCase, PascalCase, snake_case, and
+ * embedded acronyms (`verifyJWT` → ['verify', 'jwt'], `HTTPServer` →
+ * ['http', 'server']).
+ */
+function tokenizeIdentifier(name) {
+    const withBoundaries = name
+        // insert a space between a lower/digit and a following upper: verifyJWT -> verify JWT
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        // insert a space between an acronym run and a following Capitalized word:
+        // JWTUtils -> JWT Utils
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2');
+    const seen = new Set();
+    const tokens = [];
+    for (const chunk of splitWords(withBoundaries)) {
+        const token = chunk.toLowerCase();
+        if (seen.has(token))
+            continue;
+        seen.add(token);
+        tokens.push(token);
+    }
+    return tokens;
+}
+function clamp01(value) {
+    if (value < 0)
+        return 0;
+    if (value > 1)
+        return 1;
+    return value;
+}
+/** Descending weight; ties broken alphabetically for stable, deterministic output. */
+function byWeightThenName(a, b) {
+    if (b.weight !== a.weight)
+        return b.weight - a.weight;
+    return a.symbol.name.localeCompare(b.symbol.name);
+}
+//# sourceMappingURL=index.js.map

package/dist/core/ranker/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/ranker/index.ts"],"names":[],"mappings":"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"}

package/dist/core/ranker/types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Ranker contracts for ContextDiet (Task 3.0: LexicalRanker).
+ *
+ * The ranker is the bridge between a human's fuzzy intent ("Fix the JWT auth
+ * bug") and the concrete graph. It turns that focus string into a small set of
+ * high-confidence "seed" symbols that the graph traversal starts from. Like the
+ * parser, downstream code (the pruner) depends only on these interfaces, never
+ * on a concrete implementation — so the matching strategy (lexical today,
+ * embeddings later) can be swapped without a rewrite.
+ */
+import type { SymbolNode } from '../parser/types.js';
+/**
+ * A symbol the ranker believes is relevant to the focus query, paired with a
+ * confidence weight. This is the entry point ("seed") the graph traversal
+ * expands from.
+ */
+export interface SeedNode {
+    /** The matched declaration from the parser. */
+    readonly symbol: SymbolNode;
+    /**
+     * Confidence that this symbol is relevant to the focus query, in `[0, 1]`.
+     * Higher means a stronger lexical match. Callers may threshold on this to
+     * decide how many seeds to expand.
+     */
+    readonly weight: number;
+    /**
+     * The focus tokens that contributed to this match, for explainability/debug.
+     * e.g. matching `verifyJWT` against "Fix JWT auth" yields `['jwt']`.
+     */
+    readonly matchedTokens: readonly string[];
+}
+/** Tunables for lexical matching. All optional; sensible defaults are used. */
+export interface RankerOptions {
+    /**
+     * Minimum weight required for a symbol to be returned as a seed. Symbols
+     * scoring at or below this are dropped. Defaults to `0` (drop only zeros).
+     */
+    readonly minWeight?: number;
+    /**
+     * Cap on the number of seeds returned, keeping the highest-weighted. When
+     * omitted, all symbols above `minWeight` are returned.
+     */
+    readonly limit?: number;
+}
+/**
+ * The matching-engine contract. Pure and deterministic: same query + symbols
+ * always yields the same seeds, with zero I/O and zero network calls.
+ */
+export interface Ranker {
+    /**
+     * Tokenize `focusQuery` into lexical seeds, match them against `allSymbols`,
+     * and return the relevant symbols ordered by descending weight.
+     */
+    determineSeeds(focusQuery: string, allSymbols: readonly SymbolNode[]): SeedNode[];
+    /**
+     * Expose the tokenizer so tests and callers can inspect exactly which
+     * keywords a query reduces to (stop words removed, normalized, deduped).
+     */
+    tokenize(focusQuery: string): string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/ranker/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/ranker/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,+CAA+C;IAC/C,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3C;AAED,+EAA+E;AAC/E,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB;;;OAGG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,UAAU,EAAE,GAAG,QAAQ,EAAE,CAAC;IAElF;;;OAGG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CACxC"}

package/dist/core/ranker/types.js

@@ -0,0 +1,12 @@
+/**
+ * Ranker contracts for ContextDiet (Task 3.0: LexicalRanker).
+ *
+ * The ranker is the bridge between a human's fuzzy intent ("Fix the JWT auth
+ * bug") and the concrete graph. It turns that focus string into a small set of
+ * high-confidence "seed" symbols that the graph traversal starts from. Like the
+ * parser, downstream code (the pruner) depends only on these interfaces, never
+ * on a concrete implementation — so the matching strategy (lexical today,
+ * embeddings later) can be swapped without a rewrite.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/ranker/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/core/ranker/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG"}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "contextdiet-cli",
+  "version": "0.1.0",
+  "description": "AST-based token optimizer that trims codebase context for AI agents to eliminate context-window bloat and cut LLM API costs.",
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "ast",
+    "llm",
+    "context",
+    "tokens",
+    "ai-agents",
+    "ast-grep",
+    "cli"
+  ],
+  "author": "rizzhab",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/risshabs22-quantified/contextDiet.git"
+  },
+  "homepage": "https://github.com/risshabs22-quantified/contextDiet#readme",
+  "bugs": {
+    "url": "https://github.com/risshabs22-quantified/contextDiet/issues"
+  },
+  "bin": {
+    "contextdiet": "bin/contextdiet.js"
+  },
+  "main": "./dist/core/pipeline.js",
+  "types": "./dist/core/pipeline.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/core/pipeline.d.ts",
+      "default": "./dist/core/pipeline.js"
+    }
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build"
+  },
+  "dependencies": {
+    "@ast-grep/napi": "^0.44.1",
+    "commander": "^15.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.1",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  }
+}