@renseiai/agentfactory-code-intelligence 0.8.4

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

@@ -0,0 +1,22 @@
+import type { CodeSymbol, SearchQuery, SearchResult } from '../types.js';
+import { type BM25Options } from './bm25.js';
+/**
+ * High-level search engine combining BM25 ranking with filtering and exact match boosting.
+ */
+export declare class SearchEngine {
+    private index;
+    private bm25;
+    private symbols;
+    constructor(options?: BM25Options);
+    /** Build the search index from symbols. */
+    buildIndex(symbols: CodeSymbol[]): void;
+    /** Search for symbols matching a query. */
+    search(query: SearchQuery): SearchResult[];
+    /** Get index statistics. */
+    getStats(): {
+        totalSymbols: number;
+        totalTerms: number;
+    };
+    private matchPattern;
+}
+//# sourceMappingURL=search-engine.d.ts.map

package/dist/src/search/search-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-engine.d.ts","sourceRoot":"","sources":["../../../src/search/search-engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAExE,OAAO,EAAQ,KAAK,WAAW,EAAE,MAAM,WAAW,CAAA;AAElD;;GAEG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,OAAO,CAAmB;gBAEtB,OAAO,CAAC,EAAE,WAAW;IAIjC,2CAA2C;IAC3C,UAAU,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,IAAI;IAKvC,2CAA2C;IAC3C,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY,EAAE;IAyC1C,4BAA4B;IAC5B,QAAQ,IAAI;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE;IAOxD,OAAO,CAAC,YAAY;CAcrB"}

package/dist/src/search/search-engine.js

@@ -0,0 +1,76 @@
+import { InvertedIndex } from './inverted-index.js';
+import { BM25 } from './bm25.js';
+/**
+ * High-level search engine combining BM25 ranking with filtering and exact match boosting.
+ */
+export class SearchEngine {
+    index = new InvertedIndex();
+    bm25;
+    symbols = [];
+    constructor(options) {
+        this.bm25 = new BM25(options);
+    }
+    /** Build the search index from symbols. */
+    buildIndex(symbols) {
+        this.symbols = symbols;
+        this.index.build(symbols);
+    }
+    /** Search for symbols matching a query. */
+    search(query) {
+        const scored = this.bm25.score(query.query, this.index);
+        let results = [];
+        const queryLower = query.query.toLowerCase();
+        for (const { docId, score } of scored) {
+            const symbol = this.index.getDocument(docId);
+            if (!symbol)
+                continue;
+            // Apply filters
+            if (query.symbolKinds && !query.symbolKinds.includes(symbol.kind))
+                continue;
+            if (query.language && symbol.language !== query.language)
+                continue;
+            if (query.filePattern && !this.matchPattern(symbol.filePath, query.filePattern))
+                continue;
+            // Determine match type and boost exact matches
+            let matchType = 'bm25';
+            let finalScore = score;
+            if (symbol.name.toLowerCase() === queryLower) {
+                matchType = 'exact';
+                finalScore *= 3.0; // Boost exact name matches
+            }
+            else if (symbol.name.toLowerCase().includes(queryLower)) {
+                matchType = 'fuzzy';
+                finalScore *= 1.5; // Boost partial name matches
+            }
+            results.push({ symbol, score: finalScore, matchType });
+        }
+        // Sort by final score
+        results.sort((a, b) => b.score - a.score);
+        // Limit results
+        if (query.maxResults) {
+            results = results.slice(0, query.maxResults);
+        }
+        return results;
+    }
+    /** Get index statistics. */
+    getStats() {
+        return {
+            totalSymbols: this.index.getDocCount(),
+            totalTerms: this.index.getTerms().length,
+        };
+    }
+    matchPattern(filePath, pattern) {
+        // Simple glob matching: *.ts matches .ts files, src/** matches src/ prefix
+        if (pattern.startsWith('*')) {
+            return filePath.endsWith(pattern.slice(1));
+        }
+        if (pattern.endsWith('/**')) {
+            return filePath.startsWith(pattern.slice(0, -3));
+        }
+        if (pattern.endsWith('/*')) {
+            const dir = pattern.slice(0, -2);
+            return filePath.startsWith(dir) && !filePath.slice(dir.length + 1).includes('/');
+        }
+        return filePath.includes(pattern);
+    }
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Code-aware tokenizer that splits on camelCase, snake_case, kebab-case.
+ * Preserves compound tokens while also indexing sub-tokens.
+ */
+export declare class CodeTokenizer {
+    /** Tokenize a code identifier or query string. */
+    tokenize(text: string): string[];
+    /** Split camelCase/PascalCase into parts. */
+    private splitCamelCase;
+}
+//# sourceMappingURL=tokenizer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tokenizer.d.ts","sourceRoot":"","sources":["../../../src/search/tokenizer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,aAAa;IACxB,kDAAkD;IAClD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE;IAsChC,6CAA6C;IAC7C,OAAO,CAAC,cAAc;CAQvB"}

package/dist/src/search/tokenizer.js

@@ -0,0 +1,48 @@
+/**
+ * Code-aware tokenizer that splits on camelCase, snake_case, kebab-case.
+ * Preserves compound tokens while also indexing sub-tokens.
+ */
+export class CodeTokenizer {
+    /** Tokenize a code identifier or query string. */
+    tokenize(text) {
+        const tokens = [];
+        // Split on whitespace and common delimiters, but preserve _ and - for compound tokens
+        const words = text.split(/[\s.,:;()\[\]{}<>=!&|+*/\\@#$%^~`'"]+/)
+            .filter(w => w.length > 0);
+        for (const word of words) {
+            // Add the full word as a token (lowered)
+            const lower = word.toLowerCase();
+            tokens.push(lower);
+            // Split camelCase / PascalCase
+            const camelParts = this.splitCamelCase(word);
+            if (camelParts.length > 1) {
+                for (const part of camelParts) {
+                    const p = part.toLowerCase();
+                    if (p.length >= 2 && p !== lower) {
+                        tokens.push(p);
+                    }
+                }
+            }
+            // Split snake_case / kebab-case
+            const snakeParts = word.split(/[_-]/).filter(p => p.length > 0);
+            if (snakeParts.length > 1) {
+                for (const part of snakeParts) {
+                    const p = part.toLowerCase();
+                    if (p.length >= 2 && !tokens.includes(p)) {
+                        tokens.push(p);
+                    }
+                }
+            }
+        }
+        return tokens;
+    }
+    /** Split camelCase/PascalCase into parts. */
+    splitCamelCase(word) {
+        // Insert boundary before uppercase letters
+        return word
+            .replace(/([a-z])([A-Z])/g, '$1\0$2')
+            .replace(/([A-Z]+)([A-Z][a-z])/g, '$1\0$2')
+            .split('\0')
+            .filter(p => p.length > 0);
+    }
+}

package/dist/src/types.d.ts

@@ -0,0 +1,242 @@
+import { z } from 'zod';
+export declare const SymbolKindSchema: z.ZodEnum<{
+    function: "function";
+    class: "class";
+    interface: "interface";
+    type: "type";
+    variable: "variable";
+    method: "method";
+    property: "property";
+    import: "import";
+    export: "export";
+    enum: "enum";
+    struct: "struct";
+    trait: "trait";
+    impl: "impl";
+    macro: "macro";
+    decorator: "decorator";
+    module: "module";
+}>;
+export type SymbolKind = z.infer<typeof SymbolKindSchema>;
+export declare const CodeSymbolSchema: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        function: "function";
+        class: "class";
+        interface: "interface";
+        type: "type";
+        variable: "variable";
+        method: "method";
+        property: "property";
+        import: "import";
+        export: "export";
+        enum: "enum";
+        struct: "struct";
+        trait: "trait";
+        impl: "impl";
+        macro: "macro";
+        decorator: "decorator";
+        module: "module";
+    }>;
+    filePath: z.ZodString;
+    line: z.ZodNumber;
+    endLine: z.ZodOptional<z.ZodNumber>;
+    signature: z.ZodOptional<z.ZodString>;
+    documentation: z.ZodOptional<z.ZodString>;
+    exported: z.ZodDefault<z.ZodBoolean>;
+    parentName: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CodeSymbol = z.infer<typeof CodeSymbolSchema>;
+export declare const FileASTSchema: z.ZodObject<{
+    filePath: z.ZodString;
+    language: z.ZodString;
+    symbols: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            function: "function";
+            class: "class";
+            interface: "interface";
+            type: "type";
+            variable: "variable";
+            method: "method";
+            property: "property";
+            import: "import";
+            export: "export";
+            enum: "enum";
+            struct: "struct";
+            trait: "trait";
+            impl: "impl";
+            macro: "macro";
+            decorator: "decorator";
+            module: "module";
+        }>;
+        filePath: z.ZodString;
+        line: z.ZodNumber;
+        endLine: z.ZodOptional<z.ZodNumber>;
+        signature: z.ZodOptional<z.ZodString>;
+        documentation: z.ZodOptional<z.ZodString>;
+        exported: z.ZodDefault<z.ZodBoolean>;
+        parentName: z.ZodOptional<z.ZodString>;
+        language: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    imports: z.ZodArray<z.ZodString>;
+    exports: z.ZodArray<z.ZodString>;
+    hash: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FileAST = z.infer<typeof FileASTSchema>;
+export declare const FileIndexSchema: z.ZodObject<{
+    filePath: z.ZodString;
+    gitHash: z.ZodString;
+    symbols: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            function: "function";
+            class: "class";
+            interface: "interface";
+            type: "type";
+            variable: "variable";
+            method: "method";
+            property: "property";
+            import: "import";
+            export: "export";
+            enum: "enum";
+            struct: "struct";
+            trait: "trait";
+            impl: "impl";
+            macro: "macro";
+            decorator: "decorator";
+            module: "module";
+        }>;
+        filePath: z.ZodString;
+        line: z.ZodNumber;
+        endLine: z.ZodOptional<z.ZodNumber>;
+        signature: z.ZodOptional<z.ZodString>;
+        documentation: z.ZodOptional<z.ZodString>;
+        exported: z.ZodDefault<z.ZodBoolean>;
+        parentName: z.ZodOptional<z.ZodString>;
+        language: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    lastIndexed: z.ZodNumber;
+}, z.core.$strip>;
+export type FileIndex = z.infer<typeof FileIndexSchema>;
+export declare const SearchQuerySchema: z.ZodObject<{
+    query: z.ZodString;
+    maxResults: z.ZodDefault<z.ZodNumber>;
+    filePattern: z.ZodOptional<z.ZodString>;
+    symbolKinds: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        function: "function";
+        class: "class";
+        interface: "interface";
+        type: "type";
+        variable: "variable";
+        method: "method";
+        property: "property";
+        import: "import";
+        export: "export";
+        enum: "enum";
+        struct: "struct";
+        trait: "trait";
+        impl: "impl";
+        macro: "macro";
+        decorator: "decorator";
+        module: "module";
+    }>>>;
+    language: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SearchQuery = z.infer<typeof SearchQuerySchema>;
+export declare const SearchResultSchema: z.ZodObject<{
+    symbol: z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            function: "function";
+            class: "class";
+            interface: "interface";
+            type: "type";
+            variable: "variable";
+            method: "method";
+            property: "property";
+            import: "import";
+            export: "export";
+            enum: "enum";
+            struct: "struct";
+            trait: "trait";
+            impl: "impl";
+            macro: "macro";
+            decorator: "decorator";
+            module: "module";
+        }>;
+        filePath: z.ZodString;
+        line: z.ZodNumber;
+        endLine: z.ZodOptional<z.ZodNumber>;
+        signature: z.ZodOptional<z.ZodString>;
+        documentation: z.ZodOptional<z.ZodString>;
+        exported: z.ZodDefault<z.ZodBoolean>;
+        parentName: z.ZodOptional<z.ZodString>;
+        language: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    score: z.ZodNumber;
+    matchType: z.ZodEnum<{
+        exact: "exact";
+        fuzzy: "fuzzy";
+        bm25: "bm25";
+    }>;
+}, z.core.$strip>;
+export type SearchResult = z.infer<typeof SearchResultSchema>;
+export declare const MemoryEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+    xxhash: z.ZodString;
+    simhash: z.ZodBigInt;
+    createdAt: z.ZodNumber;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type MemoryEntry = z.infer<typeof MemoryEntrySchema>;
+export declare const DedupResultSchema: z.ZodObject<{
+    isDuplicate: z.ZodBoolean;
+    matchType: z.ZodEnum<{
+        exact: "exact";
+        near: "near";
+        none: "none";
+    }>;
+    existingId: z.ZodOptional<z.ZodString>;
+    hammingDistance: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type DedupResult = z.infer<typeof DedupResultSchema>;
+export declare const IndexMetadataSchema: z.ZodObject<{
+    version: z.ZodNumber;
+    rootHash: z.ZodString;
+    totalFiles: z.ZodNumber;
+    totalSymbols: z.ZodNumber;
+    lastUpdated: z.ZodNumber;
+    languages: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type IndexMetadata = z.infer<typeof IndexMetadataSchema>;
+export declare const RepoMapEntrySchema: z.ZodObject<{
+    filePath: z.ZodString;
+    rank: z.ZodNumber;
+    symbols: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            function: "function";
+            class: "class";
+            interface: "interface";
+            type: "type";
+            variable: "variable";
+            method: "method";
+            property: "property";
+            import: "import";
+            export: "export";
+            enum: "enum";
+            struct: "struct";
+            trait: "trait";
+            impl: "impl";
+            macro: "macro";
+            decorator: "decorator";
+            module: "module";
+        }>;
+        line: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RepoMapEntry = z.infer<typeof RepoMapEntrySchema>;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;EAiB3B,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAIzD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAW3B,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAIzD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOxB,CAAA;AACF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAInD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK1B,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAIvD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;iBAM5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI7B,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAI7D,eAAO,MAAM,iBAAiB;;;;;;;iBAO5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,iBAAiB;;;;;;;;;iBAK5B,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAI3D,eAAO,MAAM,mBAAmB;;;;;;;iBAO9B,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAI/D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;iBAQ7B,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/src/types.js

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+// ── Symbol Kinds ──────────────────────────────────────────────────────
+export const SymbolKindSchema = z.enum([
+    'function',
+    'class',
+    'interface',
+    'type',
+    'variable',
+    'method',
+    'property',
+    'import',
+    'export',
+    'enum',
+    'struct',
+    'trait',
+    'impl',
+    'macro',
+    'decorator',
+    'module',
+]);
+// ── Code Symbol ───────────────────────────────────────────────────────
+export const CodeSymbolSchema = z.object({
+    name: z.string().min(1),
+    kind: SymbolKindSchema,
+    filePath: z.string().min(1),
+    line: z.number().int().nonnegative(),
+    endLine: z.number().int().nonnegative().optional(),
+    signature: z.string().optional(),
+    documentation: z.string().optional(),
+    exported: z.boolean().default(false),
+    parentName: z.string().optional(),
+    language: z.string().optional(),
+});
+// ── File AST ──────────────────────────────────────────────────────────
+export const FileASTSchema = z.object({
+    filePath: z.string().min(1),
+    language: z.string().min(1),
+    symbols: z.array(CodeSymbolSchema),
+    imports: z.array(z.string()),
+    exports: z.array(z.string()),
+    hash: z.string().optional(),
+});
+// ── File Index (Merkle tree node) ─────────────────────────────────────
+export const FileIndexSchema = z.object({
+    filePath: z.string().min(1),
+    gitHash: z.string().min(1),
+    symbols: z.array(CodeSymbolSchema),
+    lastIndexed: z.number(),
+});
+// ── Search ────────────────────────────────────────────────────────────
+export const SearchQuerySchema = z.object({
+    query: z.string().min(1),
+    maxResults: z.number().int().positive().default(20),
+    filePattern: z.string().optional(),
+    symbolKinds: z.array(SymbolKindSchema).optional(),
+    language: z.string().optional(),
+});
+export const SearchResultSchema = z.object({
+    symbol: CodeSymbolSchema,
+    score: z.number().nonnegative(),
+    matchType: z.enum(['exact', 'fuzzy', 'bm25']),
+});
+// ── Memory / Dedup ────────────────────────────────────────────────────
+export const MemoryEntrySchema = z.object({
+    id: z.string().min(1),
+    content: z.string(),
+    xxhash: z.string(),
+    simhash: z.bigint(),
+    createdAt: z.number(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+export const DedupResultSchema = z.object({
+    isDuplicate: z.boolean(),
+    matchType: z.enum(['exact', 'near', 'none']),
+    existingId: z.string().optional(),
+    hammingDistance: z.number().int().nonnegative().optional(),
+});
+// ── Index Metadata ────────────────────────────────────────────────────
+export const IndexMetadataSchema = z.object({
+    version: z.number().int().positive(),
+    rootHash: z.string(),
+    totalFiles: z.number().int().nonnegative(),
+    totalSymbols: z.number().int().nonnegative(),
+    lastUpdated: z.number(),
+    languages: z.array(z.string()),
+});
+// ── Repo Map ──────────────────────────────────────────────────────────
+export const RepoMapEntrySchema = z.object({
+    filePath: z.string().min(1),
+    rank: z.number().nonnegative(),
+    symbols: z.array(z.object({
+        name: z.string(),
+        kind: SymbolKindSchema,
+        line: z.number().int().nonnegative(),
+    })),
+});

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@renseiai/agentfactory-code-intelligence",
+  "version": "0.8.4",
+  "type": "module",
+  "description": "Code intelligence for AgentFactory — tree-sitter AST parsing, BM25 search, incremental indexing, memory deduplication",
+  "author": "Rensei AI (https://rensei.ai)",
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RenseiAI/agentfactory.git",
+    "directory": "packages/code-intelligence"
+  },
+  "homepage": "https://github.com/RenseiAI/agentfactory/tree/main/packages/code-intelligence",
+  "bugs": {
+    "url": "https://github.com/RenseiAI/agentfactory/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "code-intelligence",
+    "tree-sitter",
+    "bm25",
+    "search",
+    "agent",
+    "ast"
+  ],
+  "main": "./dist/src/index.js",
+  "module": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "xxhash-wasm": "^1.1.0"
+  },
+  "peerDependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.7",
+    "zod": "^4.3.6"
+  },
+  "peerDependenciesMeta": {
+    "@anthropic-ai/claude-agent-sdk": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.5.4",
+    "typescript": "^5.7.3",
+    "vitest": "^3.2.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "pnpm clean && pnpm build"
+  }
+}