@neuralsea/workspace-indexer 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import {
+  HashEmbeddingsProvider,
+  OllamaEmbeddingsProvider,
+  OpenAIEmbeddingsProvider,
+  WorkspaceIndexer,
+  loadConfigFile
+} from "./chunk-QPQCSCBN.js";
+
+// src/cli.ts
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import fs from "fs";
+function makeEmbedder(argv) {
+  const provider = argv.provider;
+  if (provider === "ollama") {
+    return new OllamaEmbeddingsProvider({ model: argv.model, baseUrl: argv.baseUrl });
+  }
+  if (provider === "openai") {
+    const apiKey = argv.apiKey || process.env.OPENAI_API_KEY;
+    if (!apiKey) throw new Error("Missing --apiKey (or OPENAI_API_KEY) for OpenAI");
+    return new OpenAIEmbeddingsProvider({ apiKey, model: argv.model, baseUrl: argv.baseUrl });
+  }
+  return new HashEmbeddingsProvider(argv.dim);
+}
+function loadConfig(argv) {
+  const cfgPath = argv.config;
+  if (!cfgPath) return {};
+  if (!fs.existsSync(cfgPath)) throw new Error(`Config file not found: ${cfgPath}`);
+  return loadConfigFile(cfgPath);
+}
+await yargs(hideBin(process.argv)).scriptName("petri-index").option("config", { type: "string", describe: "Path to a JSON config file" }).option("provider", { type: "string", default: "ollama", choices: ["ollama", "openai", "hash"] }).option("model", { type: "string", default: "nomic-embed-text" }).option("baseUrl", { type: "string", describe: "Base URL for Ollama/OpenAI compatible endpoints" }).option("apiKey", { type: "string", describe: "API key for OpenAI (or set OPENAI_API_KEY)" }).option("dim", { type: "number", default: 384, describe: "Dimension for hash embedder" }).command(
+  "index [root]",
+  "Index all Git repos under a workspace root",
+  (y) => y.positional("root", { type: "string", default: process.cwd() }),
+  async (argv) => {
+    const cfg = loadConfig(argv);
+    const embedder = makeEmbedder(argv);
+    const ix = new WorkspaceIndexer(argv.root, embedder, cfg);
+    await ix.indexAll();
+    await ix.closeAsync();
+    console.log("Index complete.");
+  }
+).command(
+  "watch [root]",
+  "Watch and keep indexes up to date",
+  (y) => y.positional("root", { type: "string", default: process.cwd() }),
+  async (argv) => {
+    const cfg = loadConfig(argv);
+    const embedder = makeEmbedder(argv);
+    const ix = new WorkspaceIndexer(argv.root, embedder, cfg);
+    await ix.indexAll();
+    await ix.watch();
+    console.log("Watching. Press Ctrl+C to exit.");
+  }
+).command(
+  "query <q> [root]",
+  "Quick semantic search (profile: search) and print top hits",
+  (y) => y.positional("q", { type: "string", demandOption: true }).positional("root", { type: "string", default: process.cwd() }).option("k", { type: "number", default: 10 }),
+  async (argv) => {
+    const cfg = loadConfig(argv);
+    const embedder = makeEmbedder(argv);
+    const ix = new WorkspaceIndexer(argv.root, embedder, cfg);
+    await ix.indexAll();
+    const bundle = await ix.retrieve(argv.q, { profile: "search", profileOverrides: { k: argv.k } });
+    for (const h of bundle.hits) {
+      console.log(`
+[${h.score.toFixed(4)}] ${h.chunk.repoRoot} :: ${h.chunk.path}:${h.chunk.startLine}-${h.chunk.endLine} (${h.chunk.kind})`);
+      console.log(`  ${h.chunk.preview}`);
+    }
+    await ix.closeAsync();
+  }
+).command(
+  "retrieve <q> [root]",
+  "Run full retrieval with a chosen profile and output JSON context bundle",
+  (y) => y.positional("q", { type: "string", demandOption: true }).positional("root", { type: "string", default: process.cwd() }).option("profile", { type: "string", default: "search", choices: ["search", "refactor", "review", "architecture", "rca", "custom"] }).option("k", { type: "number", describe: "Override k in the profile" }).option("changedOnly", { type: "boolean", default: false, describe: "Restrict to files changed compared to baseRef" }).option("baseRef", { type: "string", default: "HEAD~1", describe: "Git ref to diff against when changedOnly is set" }),
+  async (argv) => {
+    const cfg = loadConfig(argv);
+    const embedder = makeEmbedder(argv);
+    const ix = new WorkspaceIndexer(argv.root, embedder, cfg);
+    await ix.indexAll();
+    const profile = argv.profile;
+    const bundle = await ix.retrieve(argv.q, {
+      profile,
+      profileOverrides: argv.k ? { k: argv.k } : void 0,
+      scope: argv.changedOnly ? { changedOnly: true, baseRef: argv.baseRef } : void 0
+    });
+    process.stdout.write(JSON.stringify(bundle, null, 2) + "\n");
+    await ix.closeAsync();
+  }
+).demandCommand().strict().help().parseAsync();

package/dist/index.d.ts

@@ -0,0 +1,505 @@
+type RepoId = string;
+type RetrievalProfileName = "search" | "refactor" | "review" | "architecture" | "rca" | "custom";
+interface RetrievalWeights {
+    /** Weight for semantic vector similarity (cosine). */
+    vector: number;
+    /** Weight for lexical/BM25-style match (SQLite FTS). */
+    lexical: number;
+    /** Weight for file recency (mtime). */
+    recency: number;
+}
+interface RetrievalProfile {
+    name: RetrievalProfileName;
+    /** Number of primary hits to return (before expansion). */
+    k: number;
+    /** Hybrid scoring weights. */
+    weights: RetrievalWeights;
+    /** Context expansion knobs. */
+    expand: RelatedContextOptions & {
+        /**
+         * If true, include a lightweight file-level synopsis chunk (if available),
+         * useful for architecture-style queries.
+         */
+        includeFileSynopsis?: boolean;
+    };
+    /** Candidate selection knobs. */
+    candidates?: {
+        /** How many candidates to request from vector search before merging. */
+        vectorK?: number;
+        /** How many candidates to request from lexical search before merging. */
+        lexicalK?: number;
+        /** Optional hard cap on total candidates before reranking/merging. */
+        maxMergedCandidates?: number;
+    };
+}
+/** The default profiles can be overridden or extended by the consumer. */
+interface ProfilesConfig {
+    profiles?: Partial<Record<RetrievalProfileName, Partial<RetrievalProfile>>>;
+}
+/** Similarity metric for vector search. */
+type VectorMetric = "cosine" | "ip" | "l2";
+/** Built-in vector backends. */
+type VectorProviderKind = "auto" | "bruteforce" | "hnswlib" | "qdrant" | "faiss" | "custom";
+interface HnswlibVectorConfig {
+    /** Max elements for the HNSW index (will auto-resize if needed). */
+    maxElements?: number;
+    /** HNSW M parameter (graph connectivity). */
+    m?: number;
+    /** HNSW efConstruction parameter. */
+    efConstruction?: number;
+    /** HNSW efSearch parameter (quality/speed at query time). */
+    efSearch?: number;
+    /** Persist the ANN index to disk under cacheDir (default true). */
+    persist?: boolean;
+    /** Debounce in ms before writing a dirty index to disk (default 2000). */
+    persistDebounceMs?: number;
+}
+interface QdrantVectorConfig {
+    /** Prefer `url` if set, otherwise `host`+`port`. */
+    url?: string;
+    host?: string;
+    port?: number;
+    /** Optional API key (for secured Qdrant instances). */
+    apiKey?: string;
+    /** Collection naming prefix (default "petri"). */
+    collectionPrefix?: string;
+    /**
+     * "commit" (default): a separate collection per repo+commit.
+     * "repo": a single collection per repo; commit is stored in payload.
+     */
+    collectionMode?: "commit" | "repo";
+    /** If true, drop+recreate the collection on rebuild (default true). */
+    recreateOnRebuild?: boolean;
+}
+interface FaissVectorConfig {
+    /** Factory descriptor (default "HNSW,Flat"). */
+    descriptor?: string;
+    /** Persist the FAISS index to disk under cacheDir (default true). */
+    persist?: boolean;
+    /** Debounce in ms before writing a dirty index to disk (default 2000). */
+    persistDebounceMs?: number;
+    /** Rebuild strategy: "lazy" (default) rebuild on demand; "eager" rebuild on each write. */
+    rebuildStrategy?: "lazy" | "eager";
+}
+interface CustomVectorConfig {
+    /** ESM module path to import (relative to process.cwd() or absolute). */
+    module: string;
+    /** Named export to use (default: "default"). */
+    export?: string;
+    /** Arbitrary JSON options passed to the provider factory (optional). */
+    options?: Record<string, unknown>;
+}
+interface VectorConfig {
+    /** Which vector backend to use. Default: "bruteforce". */
+    provider?: VectorProviderKind;
+    /** Vector metric. Default: "cosine". */
+    metric?: VectorMetric;
+    /** Provider-specific options. */
+    hnswlib?: HnswlibVectorConfig;
+    qdrant?: QdrantVectorConfig;
+    faiss?: FaissVectorConfig;
+    custom?: CustomVectorConfig;
+}
+interface IndexerConfig extends ProfilesConfig {
+    cacheDir?: string;
+    /** Vector index backend (ANN) configuration. */
+    vector?: VectorConfig;
+    /** Extensions to index (lowercase, include the dot). */
+    includeExtensions?: string[];
+    /** Safety limit to avoid indexing huge binaries by accident. */
+    maxFileBytes?: number;
+    /** Chunking controls. */
+    chunk?: {
+        maxChars?: number;
+        maxLines?: number;
+        overlapLines?: number;
+    };
+    /** Embedding batch controls. */
+    embed?: {
+        batchSize?: number;
+        concurrency?: number;
+    };
+    /** Watcher controls. */
+    watch?: {
+        debounceMs?: number;
+    };
+    /** Extra ignore files (in addition to git’s excludes). */
+    ignoreFiles?: string[];
+    /**
+     * Secret hygiene:
+     * - skip obvious secret-y files by path substring
+     * - redact patterns prior to storage + embedding
+     */
+    redact?: {
+        enabled?: boolean;
+        /** If path includes any of these substrings, file is skipped. */
+        skipPathSubstrings?: string[];
+        /** Simple redactions applied before embedding/storage (keeps structure). */
+        patterns?: Array<{
+            name: string;
+            regex: RegExp;
+            replaceWith: string;
+        }>;
+    };
+    /** Storage / index tuning. */
+    storage?: {
+        /** If true, keep full chunk text in SQLite (default true). */
+        storeText?: boolean;
+        /**
+         * Lexical index mode:
+         * - "full": store the (redacted) chunk text in FTS (best retrieval, more storage)
+         * - "tokens": store only extracted identifiers/tokens (less sensitive, still good for code search)
+         * - "off": disable FTS indexing entirely (vector-only retrieval)
+         */
+        ftsMode?: "full" | "tokens" | "off";
+    };
+}
+interface ChunkRecord {
+    id: string;
+    repoId: RepoId;
+    repoRoot: string;
+    path: string;
+    language: string;
+    startLine: number;
+    endLine: number;
+    contentHash: string;
+    text: string;
+    tokens: number;
+    fileMtimeMs: number;
+    kind?: "chunk" | "synopsis";
+}
+interface SearchOptions {
+    k?: number;
+    repoRoots?: string[];
+    language?: string;
+    pathPrefix?: string;
+}
+interface RetrievalScope {
+    /** Restrict results to files that are changed compared to baseRef. */
+    changedOnly?: boolean;
+    /** e.g. "origin/main", "main", "HEAD~1". Only used if changedOnly is true. */
+    baseRef?: string;
+    /** Restrict to these file paths (POSIX rel paths within repo). */
+    includePaths?: string[];
+}
+interface RetrieveOptions {
+    /** Choose a profile; can be overridden with explicit profile settings. */
+    profile?: RetrievalProfileName;
+    /** Optional ad-hoc overrides, merged into the chosen profile. */
+    profileOverrides?: Partial<RetrievalProfile>;
+    /** Optional scope restrictions. */
+    scope?: RetrievalScope;
+    /** Filters (applied after retrieval). */
+    filters?: {
+        repoRoots?: string[];
+        language?: string;
+        pathPrefix?: string;
+    };
+}
+interface SearchHit {
+    score: number;
+    scoreBreakdown?: {
+        vector?: number;
+        lexical?: number;
+        recency?: number;
+    };
+    chunk: Omit<ChunkRecord, "text"> & {
+        preview: string;
+    };
+}
+interface RelatedContextOptions {
+    adjacentChunks?: number;
+    followImports?: number;
+}
+interface ContextBundle {
+    /** Ordered from most to least relevant. */
+    hits: SearchHit[];
+    /** Expanded supporting context blocks (deduplicated). */
+    context: Array<{
+        repoRoot: string;
+        path: string;
+        startLine: number;
+        endLine: number;
+        text: string;
+        reason: string;
+    }>;
+    /** Useful metadata for your agent’s planner/logs. */
+    stats: {
+        profile: RetrievalProfileName;
+        reposSearched: number;
+        candidates: {
+            vector: number;
+            lexical: number;
+            merged: number;
+            returned: number;
+        };
+    };
+}
+
+interface EmbeddingsProvider {
+    /** Unique identifier including model, used for caching. */
+    readonly id: string;
+    /** Dimension may be unknown until first call. */
+    readonly dimension: number | null;
+    embed(texts: string[]): Promise<Float32Array[]>;
+}
+
+declare class OpenAIEmbeddingsProvider implements EmbeddingsProvider {
+    private readonly opts;
+    readonly id: string;
+    dimension: number | null;
+    constructor(opts: {
+        apiKey: string;
+        model: string;
+        baseUrl?: string;
+    });
+    embed(texts: string[]): Promise<Float32Array[]>;
+}
+
+declare class OllamaEmbeddingsProvider implements EmbeddingsProvider {
+    readonly id: string;
+    dimension: number | null;
+    private readonly baseUrl;
+    private readonly model;
+    private readonly concurrency;
+    constructor(opts: {
+        model: string;
+        baseUrl?: string;
+        concurrency?: number;
+    });
+    private tryBatchEndpoint;
+    private embedOne;
+    embed(texts: string[]): Promise<Float32Array[]>;
+}
+
+/**
+ * Offline deterministic embedding. Not truly semantic, but:
+ * - fully offline
+ * - deterministic
+ * - useful for wiring everything up + tests
+ */
+declare class HashEmbeddingsProvider implements EmbeddingsProvider {
+    readonly id: string;
+    readonly dimension: number;
+    constructor(dimension?: number);
+    embed(texts: string[]): Promise<Float32Array[]>;
+    private embedOne;
+}
+
+declare const DEFAULT_PROFILES: Record<RetrievalProfileName, RetrievalProfile>;
+declare function deepMergeProfile(base: RetrievalProfile, patch?: Partial<RetrievalProfile>): RetrievalProfile;
+
+interface VectorPoint {
+    id: string;
+    vector: Float32Array;
+    /** Optional payload for vector databases that support it (e.g. Qdrant). */
+    payload?: Record<string, unknown>;
+}
+interface VectorSearchHit {
+    id: string;
+    /** Similarity score (higher is better). For cosine/IP this is usually in [-1, 1]. */
+    score: number;
+}
+interface VectorIndexInit {
+    repoId: string;
+    repoRoot: string;
+    commit: string;
+    branch: string;
+    cacheDir: string;
+    dimension: number;
+    metric: VectorMetric;
+}
+/**
+ * A pluggable dense-vector index.
+ *
+ * All implementations MUST return a score where larger means more similar.
+ * This package primarily expects cosine similarity.
+ */
+interface VectorIndex {
+    readonly kind: string;
+    readonly metric: VectorMetric;
+    readonly dimension: number;
+    init(init: VectorIndexInit): Promise<void>;
+    /** Full rebuild from a set of points. */
+    rebuild(points: VectorPoint[]): Promise<void>;
+    /** Insert or update points (incremental). */
+    upsert(points: VectorPoint[]): Promise<void>;
+    /** Remove points by id. */
+    remove(ids: string[]): Promise<void>;
+    /** Search for the k nearest neighbours. */
+    search(query: Float32Array, k: number): Promise<VectorSearchHit[]>;
+    /** Number of points currently indexed (best-effort for remote stores). */
+    count(): Promise<number>;
+    /** Optional: flush pending writes to disk/network. */
+    flush(): Promise<void>;
+    /** Close resources. */
+    close(): Promise<void>;
+}
+
+/**
+ * Create a vector index from config.
+ *
+ * Provider selection:
+ * - explicit provider -> that backend
+ * - auto -> qdrant (if configured), else hnswlib (if dependency present), else bruteforce
+ */
+declare function createVectorIndex(vector?: VectorConfig): Promise<VectorIndex>;
+
+interface StoredChunkRow {
+    id: string;
+    path: string;
+    language: string;
+    kind: string;
+    start_line: number;
+    end_line: number;
+    content_hash: string;
+    tokens: number;
+    file_mtime: number;
+    text: string;
+    embedding: Buffer;
+}
+declare class RepoStore {
+    private db;
+    constructor(dbPath: string);
+    /** Monotonically increases whenever the chunk-store is mutated. */
+    getStoreVersion(): number;
+    /** Internal: bump store version (call inside the same transaction that mutates chunks). */
+    private bumpStoreVersion;
+    /** Vector index sync marker (per backend kind). */
+    getVectorIndexVersion(kind: string): number;
+    setVectorIndexVersion(kind: string, storeVersion: number): void;
+    setMeta(k: string, v: string): void;
+    getMeta(k: string): string | null;
+    getFileHash(posixPath: string): string | null;
+    getFileMtime(posixPath: string): number | null;
+    upsertFile(posixPath: string, hash: string, mtime: number, language: string, size: number): void;
+    deleteFile(posixPath: string): void;
+    replaceChunksForFile(posixPath: string, rows: Array<{
+        id: string;
+        language: string;
+        kind: "chunk" | "synopsis";
+        startLine: number;
+        endLine: number;
+        contentHash: string;
+        text: string;
+        ftsText: string;
+        tokens: number;
+        fileMtime: number;
+        embedding: Float32Array;
+    }>): void;
+    setEdges(fromPath: string, kind: string, values: string[]): void;
+    listEdges(fromPath: string, kind: string): string[];
+    listAllFiles(): string[];
+    countChunks(): number;
+    /**
+     * Returns the embedding dimension if any chunks exist, otherwise null.
+     * Efficient (doesn't load all embeddings).
+     */
+    getAnyEmbeddingDimension(): number | null;
+    loadAllChunkEmbeddings(): Array<{
+        id: string;
+        embedding: Float32Array;
+    }>;
+    getChunkById(id: string): StoredChunkRow | null;
+    listChunksForFile(posixPath: string, kind?: "chunk" | "synopsis"): Array<{
+        id: string;
+        start_line: number;
+        end_line: number;
+        kind: string;
+    }>;
+    /**
+     * Best-effort lexical search using SQLite FTS5.
+     * Returns ids with bm25 values (lower is better).
+     */
+    searchFts(ftq: string, limit: number, includePaths?: string[]): Array<{
+        id: string;
+        bm25: number;
+    }>;
+    close(): void;
+}
+
+declare class RepoIndexer {
+    private readonly embedder;
+    readonly repoRoot: string;
+    readonly repoId: string;
+    private config;
+    private store;
+    private vec;
+    private vecFlushTimer;
+    private vecFlushInFlight;
+    private embeddingCache;
+    private currentCommit;
+    private currentBranch;
+    private watcher;
+    private fileIgnore;
+    private serial;
+    private chunkCache;
+    constructor(repoRoot: string, embedder: EmbeddingsProvider, config?: IndexerConfig);
+    getCommit(): string | null;
+    getBranch(): string | null;
+    getStore(): RepoStore | null;
+    private dbPathForCommit;
+    private shouldIndexPath;
+    private applyRedactions;
+    private vectorMetric;
+    private vectorFlushDebounceMs;
+    private scheduleVectorFlush;
+    private flushVectorNow;
+    private ensureVectorIndex;
+    openForCurrentHead(): Promise<void>;
+    indexAll(): Promise<void>;
+    indexFile(posixRelPath: string): Promise<void>;
+    private deleteFileInner;
+    deleteFile(posixRelPath: string): Promise<void>;
+    vectorCandidates(queryEmbedding: Float32Array, k: number, includePaths?: string[]): Promise<Array<{
+        id: string;
+        score: number;
+    }>>;
+    lexicalCandidates(queryText: string, k: number, includePaths?: string[]): Promise<Array<{
+        id: string;
+        score: number;
+    }>>;
+    private getChunkRowCached;
+    private readChunkTextFallback;
+    getChunkRecord(id: string): ChunkRecord | null;
+    getChunkMeta(id: string): Omit<ChunkRecord, "text"> | null;
+    getChunkText(id: string): string;
+    getChunkPreview(id: string): string;
+    /**
+     * Expand context around a hit:
+     * - adjacency (previous/next chunks in file)
+     * - follow relative imports to include imported file synopses/headers
+     */
+    expandContext(chunkId: string, opts: {
+        adjacentChunks: number;
+        followImports: number;
+        includeFileSynopsis: boolean;
+    }): Promise<Array<{
+        id: string;
+        reason: string;
+    }>>;
+    watch(): Promise<void>;
+    closeAsync(): Promise<void>;
+    close(): void;
+}
+
+declare class WorkspaceIndexer {
+    private readonly workspaceRoot;
+    private readonly embedder;
+    private repos;
+    private config;
+    constructor(workspaceRoot: string, embedder: EmbeddingsProvider, config?: IndexerConfig);
+    open(): Promise<void>;
+    indexAll(): Promise<void>;
+    watch(): Promise<void>;
+    getRepoIndexers(): RepoIndexer[];
+    private resolveProfile;
+    retrieve(query: string, opts?: RetrieveOptions): Promise<ContextBundle>;
+    search(query: string, k?: number): Promise<SearchHit[]>;
+    closeAsync(): Promise<void>;
+    close(): void;
+}
+
+declare function loadConfigFile(filePath: string): IndexerConfig;
+
+export { type ChunkRecord, type ContextBundle, type CustomVectorConfig, DEFAULT_PROFILES, type EmbeddingsProvider, type FaissVectorConfig, HashEmbeddingsProvider, type HnswlibVectorConfig, type IndexerConfig, OllamaEmbeddingsProvider, OpenAIEmbeddingsProvider, type ProfilesConfig, type QdrantVectorConfig, type RelatedContextOptions, type RepoId, RepoIndexer, type RetrievalProfile, type RetrievalProfileName, type RetrievalScope, type RetrievalWeights, type RetrieveOptions, type SearchHit, type SearchOptions, type VectorConfig, type VectorIndex, type VectorIndexInit, type VectorMetric, type VectorPoint, type VectorProviderKind, type VectorSearchHit, WorkspaceIndexer, createVectorIndex, deepMergeProfile, loadConfigFile };

package/dist/index.js

@@ -0,0 +1,22 @@
+import {
+  DEFAULT_PROFILES,
+  HashEmbeddingsProvider,
+  OllamaEmbeddingsProvider,
+  OpenAIEmbeddingsProvider,
+  RepoIndexer,
+  WorkspaceIndexer,
+  createVectorIndex,
+  deepMergeProfile,
+  loadConfigFile
+} from "./chunk-QPQCSCBN.js";
+export {
+  DEFAULT_PROFILES,
+  HashEmbeddingsProvider,
+  OllamaEmbeddingsProvider,
+  OpenAIEmbeddingsProvider,
+  RepoIndexer,
+  WorkspaceIndexer,
+  createVectorIndex,
+  deepMergeProfile,
+  loadConfigFile
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@neuralsea/workspace-indexer",
+  "version": "0.1.0",
+  "description": "Local-first multi-repo workspace indexer (semantic embeddings + git-aware incremental updates + hybrid retrieval profiles) for AI agents.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "petri-index": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts src/cli.ts --format esm --dts --watch",
+    "lint": "node -e \"console.log('Add eslint if desired')\"",
+    "test": "node --test dist/test.js || echo \"(optional)\""
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.5.0",
+    "chokidar": "^5.0.0",
+    "ignore": "^7.0.5",
+    "p-limit": "^7.2.0",
+    "yargs": "^18.0.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.0.3",
+    "@types/yargs": "^17.0.35",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}