@wrongstack/tools 0.320.1 → 1.0.0

package/dist/codebase-index/codebase-outgoing-calls-tool.d.ts

@@ -16,13 +16,14 @@
 import type { Tool } from '@wrongstack/core/types';
 import type { CallSite } from './schema.js';
 export declare const codebaseOutgoingCallsTool: Tool<OutgoingCallsInput, OutgoingCallsOutput>;
-interface OutgoingCallsInput {
+export interface OutgoingCallsInput {
     symbol: string;
     file?: string | undefined;
     limit?: number | undefined;
     transitive?: boolean | undefined;
 }
-interface OutgoingCallsOutput {
+export type CodebaseOutgoingCallsInput = OutgoingCallsInput;
+export interface OutgoingCallsOutput {
     symbol: string;
     calls: CallSite[];
     total: number;
@@ -37,5 +38,5 @@ interface OutgoingCallsOutput {
     /** Advisory note when the symbol was not found, or unresolved refs exist. */
     note?: string | undefined;
 }
-export {};
+export type CodebaseOutgoingCallsOutput = OutgoingCallsOutput;
 //# sourceMappingURL=codebase-outgoing-calls-tool.d.ts.map

package/dist/codebase-index/codebase-repo-map-tool.d.ts

@@ -8,16 +8,15 @@
  */
 import type { Tool } from '@wrongstack/core/types';
 import { type RepoMapResult } from './repo-map.js';
-interface CodebaseRepoMapInput {
+export interface CodebaseRepoMapInput {
     /** Maximum token budget (approximate) for the generated map. Defaults to 1200. */
     maxTokens?: number | undefined;
     /** Optional file paths to prioritize and boost in the map generation. */
     focusFiles?: string[] | undefined;
 }
-interface CodebaseRepoMapOutput extends RepoMapResult {
+export interface CodebaseRepoMapOutput extends RepoMapResult {
     status: 'ok' | 'error';
     error?: string | undefined;
 }
 export declare const codebaseRepoMapTool: Tool<CodebaseRepoMapInput, CodebaseRepoMapOutput>;
-export {};
 //# sourceMappingURL=codebase-repo-map-tool.d.ts.map

package/dist/codebase-index/codebase-search-tool.d.ts

@@ -27,7 +27,7 @@ import type { SearchResult, SymbolLang } from './schema.js';
  */
 export declare const INDEXABLE_LANG_IDS: readonly SymbolLang[];
 export declare const codebaseSearchTool: Tool<CodebaseSearchInput, CodebaseSearchOutput>;
-interface CodebaseSearchInput {
+export interface CodebaseSearchInput {
     query: string;
     kind?: string | undefined;
     lang?: string | undefined;
@@ -41,7 +41,7 @@ interface CodebaseSearchInput {
      */
     preferLsp?: boolean | undefined;
 }
-interface CodebaseSearchOutput {
+export interface CodebaseSearchOutput {
     results: SearchResult[];
     total: number;
     query: string;
@@ -54,5 +54,4 @@ interface CodebaseSearchOutput {
     /** Non-empty when the index blocked the search (not ready, indexing, failed). */
     indexStatus?: string | undefined;
 }
-export {};
 //# sourceMappingURL=codebase-search-tool.d.ts.map

package/dist/codebase-index/codebase-skeleton-tool.d.ts

@@ -13,13 +13,13 @@
  */
 import type { Tool } from '@wrongstack/core/types';
 import { type FileSkeletonResult, type SkeletonOptions } from './skeleton-extractor.js';
-interface CodebaseSkeletonInput extends SkeletonOptions {
+export interface CodebaseSkeletonInput extends SkeletonOptions {
     /** Relative or absolute file or directory path. */
     path: string;
     /** Maximum number of files to process if `path` is a directory. Defaults to 20. */
     maxFiles?: number;
 }
-interface CodebaseSkeletonOutput {
+export interface CodebaseSkeletonOutput {
     path: string;
     isDir: boolean;
     skeleton: string;
@@ -33,5 +33,4 @@ interface CodebaseSkeletonOutput {
     files?: FileSkeletonResult[];
 }
 export declare const codebaseSkeletonTool: Tool<CodebaseSkeletonInput, CodebaseSkeletonOutput>;
-export {};
 //# sourceMappingURL=codebase-skeleton-tool.d.ts.map

package/dist/codebase-index/codebase-stats-tool.d.ts

@@ -6,8 +6,15 @@
  * Returns: { totalSymbols, totalFiles, byLang, byKind, lastIndexed, sizeBytes, version }
  */
 import type { Tool } from '@wrongstack/core/types';
-export declare const codebaseStatsTool: Tool<Record<string, never>, CodebaseStatsOutput>;
-interface CodebaseStatsOutput {
+/**
+ * `codebase-stats` takes no arguments (its JSON schema is
+ * `properties: {}, additionalProperties: false`). Expressed as a type alias
+ * rather than an empty interface, which is structurally `{}` — a type that
+ * accepts any non-nullish value and is flagged by `noEmptyInterface`.
+ */
+export type CodebaseStatsInput = Record<string, never>;
+export declare const codebaseStatsTool: Tool<CodebaseStatsInput, CodebaseStatsOutput>;
+export interface CodebaseStatsOutput {
     totalSymbols: number;
     totalFiles: number;
     byLang: Record<string, number>;
@@ -26,5 +33,4 @@ interface CodebaseStatsOutput {
     /** Non-empty when the index is not ready or is still building. */
     indexStatus?: string | undefined;
 }
-export {};
 //# sourceMappingURL=codebase-stats-tool.d.ts.map

package/dist/codebase-index/codebase-targeted-test-tool.d.ts

@@ -8,7 +8,7 @@
  * })
  */
 import type { Tool } from '@wrongstack/core/types';
-interface TargetedTestInput {
+export interface TargetedTestInput {
     /** Symbol name (function, class, method) whose tests should be discovered and run. */
     symbol?: string | undefined;
     /** Source file path whose corresponding test suite should be run. */
@@ -16,7 +16,8 @@ interface TargetedTestInput {
     /** Optional explicit list of test files to run. */
     testFiles?: string[] | undefined;
 }
-interface TargetedTestOutput {
+export type CodebaseTargetedTestInput = TargetedTestInput;
+export interface TargetedTestOutput {
     status: 'passed' | 'failed' | 'no_tests_found' | 'error';
     discoveredSuites: string[];
     testsRun: number;
@@ -26,6 +27,6 @@ interface TargetedTestOutput {
     output: string;
     error?: string | undefined;
 }
+export type CodebaseTargetedTestOutput = TargetedTestOutput;
 export declare const codebaseTargetedTestTool: Tool<TargetedTestInput, TargetedTestOutput>;
-export {};
 //# sourceMappingURL=codebase-targeted-test-tool.d.ts.map

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

@@ -18,18 +18,18 @@ export { cancelPendingReindexes, checkCodebaseIndexServerHealth, codebaseIndexSt
 export { buildBm25Index, buildIndexableText, tokenise, } from './bm25.js';
 export type { CircuitSnapshot, CircuitState } from './circuit-breaker.js';
 export { CircuitOpenError, IndexCircuitBreaker, IndexTimeoutError, indexCircuitBreaker, resetIndexCircuitBreaker, } from './circuit-breaker.js';
-export { codebaseAstReplaceTool } from './codebase-ast-replace-tool.js';
-export { codebaseInvariantCheckTool } from './codebase-invariant-check-tool.js';
+export { codebaseAstReplaceTool, type CodebaseAstReplaceInput, type CodebaseAstReplaceOutput, } from './codebase-ast-replace-tool.js';
+export { codebaseInvariantCheckTool, type CodebaseInvariantCheckInput, type CodebaseInvariantCheckOutput, } from './codebase-invariant-check-tool.js';
 export { replaceSymbolInFile, type MutateSymbolOptions, type MutateSymbolResult, } from './ast-symbol-mutator.js';
-export { codebaseImpactAnalysisTool } from './codebase-impact-analysis-tool.js';
-export { codebaseIncomingCallsTool } from './codebase-incoming-calls-tool.js';
-export { codebaseIndexTool } from './codebase-index-tool.js';
-export { codebaseOutgoingCallsTool } from './codebase-outgoing-calls-tool.js';
-export { codebaseRepoMapTool } from './codebase-repo-map-tool.js';
-export { codebaseSearchTool } from './codebase-search-tool.js';
-export { codebaseSkeletonTool } from './codebase-skeleton-tool.js';
-export { codebaseStatsTool } from './codebase-stats-tool.js';
-export { codebaseTargetedTestTool } from './codebase-targeted-test-tool.js';
+export { codebaseImpactAnalysisTool, type CodebaseImpactAnalysisInput, type CodebaseImpactAnalysisOutput, type ImpactAnalysisInput, type ImpactAnalysisOutput, type ImpactCallSite, } from './codebase-impact-analysis-tool.js';
+export { codebaseIncomingCallsTool, type CodebaseIncomingCallsInput, type CodebaseIncomingCallsOutput, type IncomingCallsInput, type IncomingCallsOutput, } from './codebase-incoming-calls-tool.js';
+export { codebaseIndexTool, type CodebaseIndexInput, type CodebaseIndexOutput, } from './codebase-index-tool.js';
+export { codebaseOutgoingCallsTool, type CodebaseOutgoingCallsInput, type CodebaseOutgoingCallsOutput, type OutgoingCallsInput, type OutgoingCallsOutput, } from './codebase-outgoing-calls-tool.js';
+export { codebaseRepoMapTool, type CodebaseRepoMapInput, type CodebaseRepoMapOutput, } from './codebase-repo-map-tool.js';
+export { codebaseSearchTool, type CodebaseSearchInput, type CodebaseSearchOutput, } from './codebase-search-tool.js';
+export { codebaseSkeletonTool, type CodebaseSkeletonInput, type CodebaseSkeletonOutput, } from './codebase-skeleton-tool.js';
+export { codebaseStatsTool, type CodebaseStatsInput, type CodebaseStatsOutput, } from './codebase-stats-tool.js';
+export { codebaseTargetedTestTool, type CodebaseTargetedTestInput, type CodebaseTargetedTestOutput, type TargetedTestInput, type TargetedTestOutput, } from './codebase-targeted-test-tool.js';
 export { generateRepoMap, type RepoMapOptions, type RepoMapResult, } from './repo-map.js';
 export { extractDirectorySkeleton, extractFileSkeleton, type FileSkeletonResult, type SkeletonOptions, type SkeletonSymbolRange, } from './skeleton-extractor.js';
 export { deadCodeScanTool, runDeadCodeScan } from './dead-code-scan.js';

package/dist/codebase-index/index.js

@@ -18,12 +18,12 @@ import {
   polyglotInvariantEngine,
   replaceSymbolInFile,
   runDeadCodeScan
-} from "../chunk-LRDIRJJL.js";
+} from "../chunk-YEISRT4S.js";
 import "../chunk-XRNN44QY.js";
-import "../chunk-OYP27E3I.js";
+import "../chunk-DRRY6SCM.js";
 import "../chunk-SCMRM6NL.js";
-import "../chunk-ESLPBT5A.js";
-import "../chunk-HFXSNKCV.js";
+import "../chunk-HDYUBRMF.js";
+import "../chunk-7JJFC6CT.js";
 import {
   cancelPendingReindexes,
   checkCodebaseIndexServerHealth,
@@ -45,11 +45,11 @@ import {
   shutdownCodebaseIndexHost,
   shutdownCodebaseIndexServer,
   symbolGraphService
-} from "../chunk-Z5Q3TXRY.js";
+} from "../chunk-ZTCJCYLN.js";
 import {
   projectIndexServerEndpoint,
   projectIndexServerMetadataPath
-} from "../chunk-PV6HIZQD.js";
+} from "../chunk-GDDXX27P.js";
 import {
   CircuitOpenError,
   IndexCircuitBreaker,
@@ -66,7 +66,7 @@ import {
   resolveIndexDir,
   runIndexer,
   tokenise
-} from "../chunk-J43O3BOX.js";
+} from "../chunk-N3K2SFEI.js";
 import "../chunk-NU2IZ72J.js";
 import "../chunk-VVZPQPTY.js";
 import "../chunk-6IEBD27U.js";
@@ -79,7 +79,7 @@ import {
 import {
   compileGitignore,
   loadGitignoreMatcher
-} from "../chunk-DTQ75VBC.js";
+} from "../chunk-2CTZW6JQ.js";
 import "../chunk-KE7A76VC.js";
 import "../chunk-ZUFHAHTE.js";
 export {

package/dist/codebase-index/project-server-framing.d.ts

@@ -0,0 +1,29 @@
+import { type ProjectServerClientMessage, type ProjectServerMessage } from './project-server-protocol.js';
+import type { ClientState } from './project-server-types.js';
+/**
+ * Cap on outbound bytes queued for one client before it is dropped. This
+ * server pushes index-activity updates to every client, and `socket.write()`
+ * buffers without limit when its `false` return is ignored — so one client
+ * that stops reading would otherwise grow the owner's heap indefinitely. The
+ * index lives in SQLite; a dropped client re-queries on reconnect.
+ */
+export declare const MAX_CLIENT_WRITE_BUFFER_BYTES: number;
+export declare function sendServerMessage(state: ClientState, message: ProjectServerMessage): void;
+/**
+ * Frame reader for one client connection. Each frame is sniffed per first
+ * byte: `0x57` ('W') → length-prefixed MessagePack, anything else →
+ * newline-delimited JSON text. Bytes stay raw until a complete frame is
+ * assembled, so a multibyte UTF-8 sequence split across chunks is only ever
+ * decoded as part of a finished line (raw `0x0a` only occurs as the JSON
+ * delimiter — inside JSON strings `\n` is escaped — so a complete line is
+ * always complete UTF-8).
+ *
+ * The buffer is consumed with a scan offset rather than re-slicing after
+ * every frame: each parsed frame advances `scan` within the same Buffer,
+ * and the leftover tail is compacted once at the end of the call. A burst
+ * of small frames therefore costs one allocation per chunk, not one
+ * per frame (the previous slice-per-frame loop reallocated on every frame
+ * while pinning the whole parent buffer).
+ */
+export declare function consumeClientChunk(state: ClientState, chunk: Buffer, onMessage: (state: ClientState, message: ProjectServerClientMessage) => void): void;
+//# sourceMappingURL=project-server-framing.d.ts.map

package/dist/codebase-index/project-server-lifecycle.d.ts

@@ -0,0 +1,20 @@
+import type { ProjectIndexServerMetadata } from './project-server-protocol.js';
+export declare function removeMetadataIfOwned(metadataPath: string, pid: number): void;
+export declare function writeProjectServerMetadata(metadataPath: string, metadata: ProjectIndexServerMetadata): Promise<void>;
+/**
+ * One SIGINT/SIGTERM pair per PROCESS, not per module instance.
+ *
+ * The in-process test harness imports this module once per test case with a
+ * `?case=<n>` query URL, so every case evaluates this module body fresh; a
+ * bare top-level `process.once(signal, ...)` pair accumulates one handler
+ * per case until Node raises MaxListenersExceededWarning in every coverage
+ * run. The guard lives on globalThis under a Symbol.for key: the first
+ * evaluation registers the pair, every evaluation re-targets it at its own
+ * `stop`, and a fired signal removes the pair (once semantics).
+ */
+export interface CodebaseIndexSignalGuard {
+    arm(stop: (signal: string) => Promise<void>): void;
+}
+export declare const SIGNAL_GUARD: unique symbol;
+export declare function armCodebaseIndexSignalGuard(stop: (signal: string) => Promise<void>): void;
+//# sourceMappingURL=project-server-lifecycle.d.ts.map

package/dist/codebase-index/project-server-operations.d.ts

@@ -0,0 +1,37 @@
+import type { ProjectIndexServerActivity, ProjectServerClientMessage, ProjectServerMessage } from './project-server-protocol.js';
+import { type ServerQueryCaches } from './project-server-query-cache.js';
+import type { ActiveFullIndex, ClientState } from './project-server-types.js';
+import type { IndexOpArgs, OpShapes } from './worker-protocol.js';
+export interface OperationContext {
+    projectRoot: string;
+    indexDir: string;
+    queryCaches: ServerQueryCaches;
+    getActivity: () => ProjectIndexServerActivity;
+    withIndexWrite: <T>(job: (onProgress: (currentFile: number, totalFiles: number) => void) => Promise<T>, options: {
+        preserveCaches: boolean;
+    }) => Promise<T>;
+    send: (state: ClientState, message: ProjectServerMessage) => void;
+    getActiveFullIndex: () => ActiveFullIndex | null;
+    setActiveFullIndex: (active: ActiveFullIndex | null) => void;
+}
+/**
+ * Cache policy at write-run completion.
+ *
+ * A run with an explicit targeted file list (edit/watcher reindex) makes a
+ * per-file surgical change, so — on success — every previous-generation entry
+ * stays valid as a stale answer for the NEXT refresh. On failure the run's
+ * transaction rolls back, which equally leaves the cached entries describing
+ * the on-disk truth. (Precision: the rollback is per-file — a multi-file
+ * targeted run commits the files that parsed and rolls back only the failed
+ * one — but each file's slice is atomic, and queries never straddle slices,
+ * so cached answers stay correct.) Anything else (full scan, force rebuild,
+ * langs/ignore-filtered scan) can reshape the whole index, so its caches are
+ * dropped on completion and on failure alike.
+ */
+export declare function preservesQueryCaches(args: IndexOpArgs): boolean;
+export declare function isShareableFullIndex(args: IndexOpArgs): boolean;
+export declare function runFullIndex(ctx: OperationContext, state: ClientState, id: number, args: IndexOpArgs): Promise<OpShapes['index']['result']>;
+export declare function dispatchOperation(ctx: OperationContext, state: ClientState, message: Extract<ProjectServerClientMessage, {
+    type: 'request';
+}>): Promise<unknown>;
+//# sourceMappingURL=project-server-operations.d.ts.map

package/dist/codebase-index/project-server-types.d.ts

@@ -0,0 +1,30 @@
+import type * as net from 'node:net';
+import type { OpShapes } from './worker-protocol.js';
+export interface ClientState {
+    socket: net.Socket;
+    /**
+     * Raw inbound bytes. Frames may be newline-delimited JSON or length-
+     * prefixed binary (magic 0x57); the mode is sniffed per frame. Kept as
+     * bytes because a JSON text line may split a multibyte UTF-8 sequence at a
+     * chunk boundary — the StringDecoder handles that at parse time.
+     */
+    buffer: Buffer;
+    cancelled: Set<number>;
+    cancel: Map<number, () => void>;
+    watchExternal: boolean;
+    debounceMs: number;
+    coalesceWindowMs: number;
+    lastSeenAt: number;
+    /** True once this client has sent at least one binary frame. */
+    binary: boolean;
+}
+export interface FullIndexSubscriber {
+    state: ClientState;
+    id: number;
+}
+export interface ActiveFullIndex {
+    promise: Promise<OpShapes['index']['result']>;
+    controller: AbortController;
+    subscribers: Set<FullIndexSubscriber>;
+}
+//# sourceMappingURL=project-server-types.d.ts.map

package/dist/codebase-index/project-server-watcher.d.ts

@@ -0,0 +1,25 @@
+import type { ClientState } from './project-server-types.js';
+export declare const DEFAULT_EXTERNAL_DEBOUNCE_MS = 400;
+export declare const DEFAULT_EXTERNAL_COALESCE_WINDOW_MS = 50;
+export declare function isIgnoredRelativePath(relativePath: string): boolean;
+export interface ProjectServerWatcherOptions {
+    projectRoot: string;
+    onFilesChanged: (files: string[]) => void;
+}
+export declare class ProjectServerWatcherManager {
+    private readonly options;
+    private externalWatcher;
+    private externalDebounceMs;
+    private externalCoalesceWindowMs;
+    private readonly externalDebounceTimers;
+    private readonly externalReadyFiles;
+    private externalReadyFlush;
+    constructor(options: ProjectServerWatcherOptions);
+    get isWatching(): boolean;
+    get pendingFileCount(): number;
+    private enqueueExternalFile;
+    private ensureExternalWatcher;
+    stop(): void;
+    reconcile(clients: Iterable<ClientState>): void;
+}
+//# sourceMappingURL=project-server-watcher.d.ts.map