token-pilot 0.30.0 → 0.30.1

package/dist/core/edit-prep-state.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Shared disk state so a PreToolUse:Edit hook subprocess can tell whether
+ * the main-thread agent actually called `read_for_edit` before the Edit.
+ *
+ * Why file-backed: hook subprocesses spawn fresh per-call and see no
+ * in-process state from the MCP server. Keyed by a hash of projectRoot so
+ * two concurrent projects on the same machine don't cross-contaminate.
+ * Entries expire after 30 minutes — long enough to cover a typical edit
+ * session, short enough that a stale prep from a previous conversation
+ * doesn't let a bad Edit slip through tomorrow.
+ *
+ * All operations are best-effort: any I/O error is swallowed silently.
+ * A broken state file must NEVER block an Edit — it's a soft guardrail,
+ * not a file-system invariant. If the prep file is unreadable we act as
+ * if "no prep exists" and the hook behaves per its enforcement mode.
+ */
+declare function stateDir(): string;
+declare function stateFile(projectRoot: string): string;
+/**
+ * Record that `read_for_edit` was just called for `absPath`.
+ * Safe to call in any order, from any process — atomically rewrites the
+ * state file so a racing read never sees a half-written JSON.
+ */
+export declare function markEditPrepared(projectRoot: string, absPath: string, now?: number): void;
+/**
+ * Has `read_for_edit` been called for `absPath` recently enough to
+ * authorise a follow-up Edit? Auto-prunes entries older than TTL.
+ */
+export declare function isEditPrepared(projectRoot: string, absPath: string, now?: number, ttlMs?: number): boolean;
+/**
+ * Clear all prep state for a project root. Intended for tests and for the
+ * `doctor` CLI if we ever want an explicit reset button.
+ */
+export declare function clearEditPrep(projectRoot: string): void;
+/** Exposed for tests so they don't need to import tmpdir themselves. */
+export declare const __test__: {
+    stateDir: typeof stateDir;
+    stateFile: typeof stateFile;
+    DEFAULT_TTL_MS: number;
+};
+export {};
+//# sourceMappingURL=edit-prep-state.d.ts.map

package/dist/core/edit-prep-state.js

@@ -0,0 +1,108 @@
+/**
+ * Shared disk state so a PreToolUse:Edit hook subprocess can tell whether
+ * the main-thread agent actually called `read_for_edit` before the Edit.
+ *
+ * Why file-backed: hook subprocesses spawn fresh per-call and see no
+ * in-process state from the MCP server. Keyed by a hash of projectRoot so
+ * two concurrent projects on the same machine don't cross-contaminate.
+ * Entries expire after 30 minutes — long enough to cover a typical edit
+ * session, short enough that a stale prep from a previous conversation
+ * doesn't let a bad Edit slip through tomorrow.
+ *
+ * All operations are best-effort: any I/O error is swallowed silently.
+ * A broken state file must NEVER block an Edit — it's a soft guardrail,
+ * not a file-system invariant. If the prep file is unreadable we act as
+ * if "no prep exists" and the hook behaves per its enforcement mode.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
+import { createHash } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+const STATE_DIR_NAME = "token-pilot-edit-prep";
+const DEFAULT_TTL_MS = 30 * 60 * 1000; // 30 minutes
+function stateDir() {
+    return join(tmpdir(), STATE_DIR_NAME);
+}
+function stateFile(projectRoot) {
+    const hash = createHash("sha1")
+        .update(resolve(projectRoot))
+        .digest("hex")
+        .slice(0, 16);
+    return join(stateDir(), `${hash}.json`);
+}
+function loadState(projectRoot) {
+    try {
+        const txt = readFileSync(stateFile(projectRoot), "utf-8");
+        const parsed = JSON.parse(txt);
+        if (parsed &&
+            typeof parsed === "object" &&
+            "paths" in parsed &&
+            typeof parsed.paths === "object") {
+            return parsed;
+        }
+    }
+    catch {
+        /* corrupt / missing — fall through */
+    }
+    return { paths: {} };
+}
+function pruneExpired(state, ttlMs, now) {
+    const fresh = {};
+    for (const [p, ts] of Object.entries(state.paths)) {
+        if (typeof ts === "number" && now - ts < ttlMs) {
+            fresh[p] = ts;
+        }
+    }
+    return { paths: fresh };
+}
+/**
+ * Record that `read_for_edit` was just called for `absPath`.
+ * Safe to call in any order, from any process — atomically rewrites the
+ * state file so a racing read never sees a half-written JSON.
+ */
+export function markEditPrepared(projectRoot, absPath, now = Date.now()) {
+    try {
+        const dir = stateDir();
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        const state = pruneExpired(loadState(projectRoot), DEFAULT_TTL_MS, now);
+        state.paths[resolve(absPath)] = now;
+        const file = stateFile(projectRoot);
+        const tmp = `${file}.${process.pid}.tmp`;
+        writeFileSync(tmp, JSON.stringify(state));
+        renameSync(tmp, file);
+    }
+    catch {
+        /* best-effort — see module doc */
+    }
+}
+/**
+ * Has `read_for_edit` been called for `absPath` recently enough to
+ * authorise a follow-up Edit? Auto-prunes entries older than TTL.
+ */
+export function isEditPrepared(projectRoot, absPath, now = Date.now(), ttlMs = DEFAULT_TTL_MS) {
+    const state = pruneExpired(loadState(projectRoot), ttlMs, now);
+    return typeof state.paths[resolve(absPath)] === "number";
+}
+/**
+ * Clear all prep state for a project root. Intended for tests and for the
+ * `doctor` CLI if we ever want an explicit reset button.
+ */
+export function clearEditPrep(projectRoot) {
+    try {
+        const file = stateFile(projectRoot);
+        if (existsSync(file)) {
+            writeFileSync(file, JSON.stringify({ paths: {} }));
+        }
+    }
+    catch {
+        /* best effort */
+    }
+}
+/** Exposed for tests so they don't need to import tmpdir themselves. */
+export const __test__ = {
+    stateDir,
+    stateFile,
+    DEFAULT_TTL_MS,
+};
+//# sourceMappingURL=edit-prep-state.js.map

package/dist/handlers/explore-area.js

@@ -42,7 +42,12 @@ export async function handleExploreArea(args, projectRoot, astIndex) {
         absPath = dirname(absPath);
     }
     const relDir = relative(projectRoot, absPath) || ".";
-    const include = args.include ?? ["outline", "imports", "tests", "changes"];
+    // v0.30.0 — narrowed default from all 4 sections to the two cheap ones.
+    // Telemetry (docker-local-env, 2026-04-24) showed the all-4 default giving
+    // negative token reduction (-7%): `imports` builds a full dep graph and
+    // `tests` walks subtrees, both easily outweighing the raw-file baseline.
+    // Callers who need imports/tests now opt in explicitly via `include`.
+    const include = args.include ?? ["outline", "changes"];
     // Collect code files for import/test analysis
     const codeFiles = await listCodeFiles(absPath);
     // Run all sections in parallel

package/dist/handlers/read-for-edit.d.ts

@@ -1,7 +1,7 @@
-import type { AstIndexClient } from '../ast-index/client.js';
-import type { SymbolResolver } from '../core/symbol-resolver.js';
-import type { FileCache } from '../core/file-cache.js';
-import type { ContextRegistry } from '../core/context-registry.js';
+import type { AstIndexClient } from "../ast-index/client.js";
+import type { SymbolResolver } from "../core/symbol-resolver.js";
+import type { FileCache } from "../core/file-cache.js";
+import type { ContextRegistry } from "../core/context-registry.js";
 export interface ReadForEditArgs {
     path: string;
     symbol?: string;
@@ -17,7 +17,7 @@ export declare function handleReadForEdit(args: ReadForEditArgs, projectRoot: st
     actionableHints?: boolean;
 }): Promise<{
     content: Array<{
-        type: 'text';
+        type: "text";
         text: string;
     }>;
 }>;