@wrongstack/tools 0.309.1 → 0.310.1

package/dist/codebase-index/writer-admin.d.ts

@@ -9,6 +9,17 @@ export declare function getAllIndexableWithStatement(stmt: PrepareStatement): Ar
 export declare function getMaxSymbolIdWithStatement(stmt: PrepareStatement): number;
 export declare function getStatsWithStatement(stmt: PrepareStatement, indexDir: string): IndexStats;
 export declare function getMetadataWithStatement(stmt: PrepareStatement, key: string): string | undefined;
+/**
+ * P2.5: minimal index summary for search responses. Carries exactly the two
+ * fields the search tool's zero-hit heuristic consumes (`totalFiles`,
+ * `lastIndexed`) — NOT the full IndexStats — so a zero-hit query answers
+ * "is there a persisted index at all?" without a second stats IPC round trip.
+ */
+export interface IndexSummary {
+    totalFiles: number;
+    lastIndexed: number | null;
+}
+export declare function getIndexSummaryWithStatement(stmt: PrepareStatement): IndexSummary;
 export declare function getFileMetaWithStatement(stmt: PrepareStatement, file: string): FileMeta | null;
 export declare function getAllFileMetasWithStatement(stmt: PrepareStatement): FileMeta[];
 export declare function getIndexDbSizeBytes(indexDir: string): number;

package/dist/codebase-index/writer-helpers.d.ts

@@ -1,5 +1,35 @@
-import type { Ref, Symbol as IndexSymbol } from './schema.js';
+import type { Symbol as IndexSymbol, Ref } from './schema.js';
 export declare function escapeLike(value: string): string;
+/**
+ * Split `total` into chunk sizes drawn from a powers-of-two ladder (each ≤
+ * `max`), largest first. Example: total=1000, max=450 → [256, 256, 256, 128,
+ * 64, 32, 8]. Distinct sizes ≤ log2(max)+1, so the same INSERT statement
+ * re-prepares at most ~9 times ever — after that every chunk size is a cache
+ * hit. INSERT VALUES rows cannot be padded (padding would insert garbage
+ * rows), so variable-size chunks are the only option there — this makes the
+ * variability bounded and tiny.
+ */
+export declare function ladderChunkSizes(total: number, max: number): number[];
+/**
+ * Pad `values` up to the next power-of-two length by repeating `values[0]`,
+ * for single-statement IN-lists whose size is caller-determined (not chunked
+ * by us). Safe because IN is set semantics: `x IN (a, a, b)` ≡ `x IN (a, b)`.
+ * The bind overhead is at most ~2×, and every list length maps to one of
+ * ~10 SQL strings instead of one per distinct count.
+ */
+export declare function padToInBucket<T>(values: readonly T[]): T[];
+/** Placeholder string with `count` bind markers — `count` should be a bucket. */
+export declare function placeholders(count: number): string;
+/**
+ * Chunk plan for IN-list sites (the pad-able counterpart to
+ * {@link ladderChunkSizes}). When the whole list fits under `max`, it is ONE
+ * chunk — a single statement, exactly like the pre-P4.12 code — and SQL-string
+ * stability comes from {@link padToInBucket} instead. Only a list that exceeds
+ * `max` is ladder-split, with the ladder capped at the largest power of two ≤
+ * max so chunks are already bucket sizes (padding is a no-op on them) and
+ * can never pad past the variable budget.
+ */
+export declare function inListChunks(total: number, max: number): number[];
 /** Normalize an indexed or user-supplied file path for comparison. */
 export declare function posixIndexPath(file: string): string;
 /**

package/dist/codebase-index/writer-mutations.d.ts

@@ -17,10 +17,4 @@ export declare function deleteSymbolsForFileWithStatement(stmtFn: (sql: string)
 export declare function deleteFileWithStatement(stmtFn: (sql: string) => ReturnType<DatabaseSync['prepare']>, ftsAvailable: boolean, vectorsAvailable: boolean, invalidateIncomingRefsForFiles: (files: readonly string[]) => Set<string>, resolveRefsForNamesUnsafe: (names: Iterable<string>) => number, file: string): void;
 export declare function upsertFileWithStatement(stmtFn: (sql: string) => ReturnType<DatabaseSync['prepare']>, meta: FileMeta): void;
 export declare function setFilePackagesWithStatement(stmtFn: (sql: string) => ReturnType<DatabaseSync['prepare']>, entries: ReadonlyMap<string, string>): void;
-export declare function applyImportResolutionsWithStatement(db: DatabaseSync, stmtFn: (sql: string) => ReturnType<DatabaseSync['prepare']>, maxSqlVars: number, resolutions: ReadonlyArray<{
-    fromFile: string;
-    lang: string;
-    module: string;
-    toFile: string;
-}>): number;
 //# sourceMappingURL=writer-mutations.d.ts.map

package/dist/codebase-index/writer-schema.d.ts

@@ -1,7 +1,7 @@
 export declare const METADATA_TABLE_SQL = "\n  CREATE TABLE IF NOT EXISTS metadata (\n    key TEXT PRIMARY KEY,\n    value TEXT NOT NULL\n  );\n";
-export declare const CORE_TABLES_SQL = "\n  CREATE TABLE IF NOT EXISTS files (\n    file TEXT PRIMARY KEY,\n    lang TEXT NOT NULL,\n    mtime_ms INTEGER NOT NULL,\n    -- Phase 2: xxHash64 of the file's UTF-8 bytes. Empty string when the\n    -- indexer hasn't populated it yet (legacy rows, schema repaired by\n    -- repairMissingColumns). Compared on incremental re-index so that a\n    -- touch or branch-switch that leaves content byte-identical skips the\n    -- expensive parse phase entirely (refactoring proposal Phase 2).\n    content_hash TEXT NOT NULL DEFAULT '',\n    symbol_count INTEGER NOT NULL DEFAULT 0,\n    last_indexed INTEGER NOT NULL,\n    -- Code Atlas grouping label, computed at index time from the ecosystem's\n    -- own manifests (package.json, go.mod, Cargo.toml, \u2026). Stored rather than\n    -- re-derived per query because the evidence lives on disk, not in the DB.\n    package TEXT NOT NULL DEFAULT ''\n  );\n  CREATE TABLE IF NOT EXISTS symbols (\n    id INTEGER PRIMARY KEY,\n    lang TEXT NOT NULL,\n    kind TEXT NOT NULL,\n    name TEXT NOT NULL,\n    file TEXT NOT NULL,\n    line INTEGER NOT NULL,\n    col INTEGER NOT NULL,\n    signature TEXT NOT NULL DEFAULT '',\n    doc_comment TEXT NOT NULL DEFAULT '',\n    scope TEXT NOT NULL DEFAULT '',\n    text TEXT NOT NULL DEFAULT '',\n    file_fk TEXT NOT NULL\n  );\n";
+export declare const CORE_TABLES_SQL = "\n  CREATE TABLE IF NOT EXISTS files (\n    file TEXT PRIMARY KEY,\n    lang TEXT NOT NULL,\n    mtime_ms INTEGER NOT NULL,\n    -- Phase 2: xxHash64 of the file's UTF-8 bytes. Empty string when the\n    -- indexer hasn't populated it yet (legacy rows, schema repaired by\n    -- repairMissingColumns). Compared on incremental re-index so that a\n    -- touch or branch-switch that leaves content byte-identical skips the\n    -- expensive parse phase entirely (refactoring proposal Phase 2).\n    content_hash TEXT NOT NULL DEFAULT '',\n    symbol_count INTEGER NOT NULL DEFAULT 0,\n    last_indexed INTEGER NOT NULL,\n    -- Code Atlas grouping label, computed at index time from the ecosystem's\n    -- own manifests (package.json, go.mod, Cargo.toml, \u2026). Stored rather than\n    -- re-derived per query because the evidence lives on disk, not in the DB.\n    package TEXT NOT NULL DEFAULT ''\n  );\n  CREATE TABLE IF NOT EXISTS symbols (\n    id INTEGER PRIMARY KEY,\n    lang TEXT NOT NULL,\n    kind TEXT NOT NULL,\n    name TEXT NOT NULL,\n    file TEXT NOT NULL,\n    line INTEGER NOT NULL,\n    col INTEGER NOT NULL,\n    signature TEXT NOT NULL DEFAULT '',\n    doc_comment TEXT NOT NULL DEFAULT '',\n    scope TEXT NOT NULL DEFAULT '',\n    text TEXT NOT NULL DEFAULT ''\n    );\n";
 export declare const FILE_INDEX_SQL: readonly ['CREATE INDEX IF NOT EXISTS idx_f_package ON files(package)'];
-export declare const SYMBOL_INDEX_SQL: readonly ['CREATE INDEX IF NOT EXISTS idx_s_name ON symbols(name)', 'CREATE INDEX IF NOT EXISTS idx_s_kind ON symbols(kind)', 'CREATE INDEX IF NOT EXISTS idx_s_lang ON symbols(lang)', 'CREATE INDEX IF NOT EXISTS idx_s_file ON symbols(file)', 'CREATE INDEX IF NOT EXISTS idx_s_lang_kind ON symbols(lang, kind)', 'CREATE INDEX IF NOT EXISTS idx_s_file_fk ON symbols(file_fk)', 'CREATE INDEX IF NOT EXISTS idx_s_name_id ON symbols(name, id)'];
+export declare const SYMBOL_INDEX_SQL: readonly ['CREATE INDEX IF NOT EXISTS idx_s_name ON symbols(name)', 'CREATE INDEX IF NOT EXISTS idx_s_kind ON symbols(kind)', 'CREATE INDEX IF NOT EXISTS idx_s_lang ON symbols(lang)', 'CREATE INDEX IF NOT EXISTS idx_s_file ON symbols(file)', 'CREATE INDEX IF NOT EXISTS idx_s_lang_kind ON symbols(lang, kind)', 'CREATE INDEX IF NOT EXISTS idx_s_name_id ON symbols(name, id)'];
 export declare const REFS_TABLE_SQL = "\n  CREATE TABLE IF NOT EXISTS refs (\n    id INTEGER PRIMARY KEY,\n    from_id INTEGER NOT NULL,\n    to_name TEXT NOT NULL,\n    to_id INTEGER,\n    call_type TEXT NOT NULL,\n    line INTEGER NOT NULL,\n    lang TEXT NOT NULL DEFAULT '',\n    module TEXT,\n    to_file TEXT\n  );\n";
 export declare const REFS_INDEX_SQL: readonly ['CREATE INDEX IF NOT EXISTS idx_r_from ON refs(from_id)', 'CREATE INDEX IF NOT EXISTS idx_r_to_id ON refs(to_id)', 'CREATE INDEX IF NOT EXISTS idx_r_to_name ON refs(to_name)', 'CREATE INDEX IF NOT EXISTS idx_r_call_type ON refs(call_type)', 'CREATE INDEX IF NOT EXISTS idx_r_to_name_lang ON refs(to_name, lang)', 'CREATE INDEX IF NOT EXISTS idx_r_module ON refs(module)', 'CREATE INDEX IF NOT EXISTS idx_r_to_file ON refs(to_file)'];
 /**

package/dist/codebase-index/writer.d.ts

@@ -1,4 +1,5 @@
 import type { CallSite, CodeMapGraph, FileMeta, IndexStats, Symbol as IndexSymbol, Ref, SearchResult, SymbolKind, SymbolLang } from './schema.js';
+import { type IndexSummary } from './writer-admin.js';
 import type { WriterSearchFilter } from './writer-search-helpers.js';
 import { StorePool } from './writer-store-pool.js';
 export { codebaseIndexDirOverride, resolveIndexDir } from './writer-helpers.js';
@@ -70,6 +71,8 @@ export declare class IndexStore {
     }>;
     getMaxSymbolId(): number;
     getStats(): IndexStats;
+    /** P2.5: minimal summary for search-response piggyback (see writer-admin). */
+    getIndexSummary(): IndexSummary;
     setLastIndexed(ts: number): void;
     getMetadata(key: string): string | undefined;
     setMetadata(key: string, value: string): void;
@@ -92,6 +95,18 @@ export declare class IndexStore {
     resolveRefsForNames(names: Iterable<string>): number;
     replaceEmptyFile(meta: FileMeta): void;
     optimize(): void;
+    /**
+     * P4.14: best-effort WAL checkpoint for idle-time maintenance.
+     *
+     * `wal_autocheckpoint` is PASSIVE and only attempts work after a COMMIT —
+     * once writes stop, nothing fires again, so the WAL keeps whatever frames
+     * the last burst left. This probes with PASSIVE first (never blocks; busy=1
+     * means readers still hold WAL snapshots) and only issues the TRUNCATE —
+     * which resets index.db-wal to zero bytes — when the checkpointer can
+     * proceed immediately. Callers run this on the daemon's single thread, so
+     * never wait on readers here: busy means "retry at the next idle window".
+     */
+    checkpointWal(): boolean;
     compactIfNeeded(options?: {
         minBytes?: number;
         minFreeRatio?: number;