token-pilot 0.19.1 → 0.22.2

package/dist/hooks/session-start.js

@@ -0,0 +1,179 @@
+/**
+ * SessionStart reminder hook — Component 2 of the enforcement layer.
+ *
+ * On every session start / /clear / /compact, emits a compact additionalContext
+ * block containing the mandatory-tool rules and a list of tp-* subagents found
+ * in the project and user agent directories.
+ *
+ * Output contract: one JSON line on stdout, or exit 0 silent.
+ */
+import { readdir, readFile } from "node:fs/promises";
+import { join, basename } from "node:path";
+import { loadLatestSnapshot } from "./../handlers/session-snapshot-persist.js";
+const SNAPSHOT_FRESH_MS = 2 * 3600 * 1000; // 2h — enough to cover compaction/restart, tight enough that a new day's unrelated work doesn't inherit yesterday's thread
+function extractSnapshotGoal(body) {
+    const m = body.match(/\*\*Goal:\*\*\s*(.+?)(?:\n|$)/);
+    return m ? m[1].trim().slice(0, 100) : null;
+}
+// ─── Agent scanner (subtask 2.2) ─────────────────────────────────────────────
+/**
+ * Parse YAML-style frontmatter from a markdown file.
+ * Only handles simple key: value pairs (no nested, no arrays).
+ * Returns an object with extracted string fields.
+ */
+function parseFrontmatter(content) {
+    const result = {};
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return result;
+    for (const line of match[1].split(/\r?\n/)) {
+        const kv = line.match(/^(\w[\w-]*):\s*(.*)$/);
+        if (kv) {
+            result[kv[1]] = kv[2].trim();
+        }
+    }
+    return result;
+}
+/**
+ * Scan one agents directory for tp-*.md files and return parsed entries.
+ */
+async function scanDir(dir) {
+    let names;
+    try {
+        names = await readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const agents = [];
+    for (const filename of names) {
+        if (!filename.startsWith("tp-") || !filename.endsWith(".md"))
+            continue;
+        try {
+            const content = await readFile(join(dir, filename), "utf-8");
+            const fm = parseFrontmatter(content);
+            const stem = basename(filename, ".md");
+            agents.push({
+                name: fm.name ?? stem,
+                description: fm.description ?? "",
+            });
+        }
+        catch {
+            // Skip unreadable files
+        }
+    }
+    return agents;
+}
+/**
+ * Scan ~/.claude/agents/ and ./.claude/agents/ for tp-*.md agent definitions.
+ * Project directory takes precedence; duplicates (by name) are dropped.
+ *
+ * @param projectRoot - absolute path to the project root
+ * @param homeDir - home directory (injected for testability; defaults to os.homedir())
+ */
+export async function scanAgents(projectRoot, homeDir) {
+    const projectAgentsDir = join(projectRoot, ".claude", "agents");
+    const homeAgentsDir = join(homeDir, ".claude", "agents");
+    const [projectAgents, homeAgents] = await Promise.all([
+        scanDir(projectAgentsDir),
+        scanDir(homeAgentsDir),
+    ]);
+    // Merge: project agents first; home agents fill in names not already present
+    const seen = new Set();
+    const merged = [];
+    for (const agent of [...projectAgents, ...homeAgents]) {
+        if (!seen.has(agent.name)) {
+            seen.add(agent.name);
+            merged.push(agent);
+        }
+    }
+    return merged;
+}
+// ─── Message builder (subtask 2.3) ───────────────────────────────────────────
+const MANDATORY_BLOCK = `[token-pilot active]
+
+MANDATORY — for code files, use these before raw Read:
+  mcp__token-pilot__smart_read(path)        — structural overview
+  mcp__token-pilot__read_symbol(path, sym)  — one function / class
+  mcp__token-pilot__read_for_edit(path, sym)— exact text for editing
+  mcp__token-pilot__outline(path)           — symbol list
+Raw Read allowed only with offset/limit or TOKEN_PILOT_BYPASS=1.`;
+function estimateTokens(text) {
+    // Fast approximation: chars / 4, adjusted for whitespace
+    if (text.length === 0)
+        return 0;
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Build the reminder message combining the mandatory-tool rules and the
+ * tp-* agent list.  Enforces the maxReminderTokens budget by trimming the
+ * delegating list with "… and N more" if needed.
+ */
+export function buildReminderMessage(agents, maxReminderTokens) {
+    const agentLines = agents.length === 0
+        ? "  none installed — run: npx token-pilot install-agents"
+        : agents.map((a) => `  ${a.name}  — ${a.description}`).join("\n");
+    const delegatingSection = `WHEN DELEGATING — use the right token-pilot-native subagent:\n${agentLines}`;
+    const full = `${MANDATORY_BLOCK}\n\n${delegatingSection}`;
+    if (estimateTokens(full) <= maxReminderTokens) {
+        return full;
+    }
+    // Trim agent list until we fit. Distinguish "all agents trimmed due to
+    // budget" (count remained >0 in the original list) from "no agents at
+    // all" — they look the same to `trimmedAgents.length === 0` but mean
+    // very different things to the caller (one requires install-agents; the
+    // other just reports "N more hidden").
+    let trimmedAgents = [...agents];
+    while (trimmedAgents.length > 0) {
+        trimmedAgents = trimmedAgents.slice(0, trimmedAgents.length - 1);
+        const dropped = agents.length - trimmedAgents.length;
+        const trimmedLines = trimmedAgents.length === 0
+            ? `  … and ${dropped} more (reminder budget exhausted)`
+            : trimmedAgents
+                .map((a) => `  ${a.name}  — ${a.description}`)
+                .join("\n") + `\n  … and ${dropped} more`;
+        const candidate = `${MANDATORY_BLOCK}\n\nWHEN DELEGATING — use the right token-pilot-native subagent:\n${trimmedLines}`;
+        if (estimateTokens(candidate) <= maxReminderTokens) {
+            return candidate;
+        }
+    }
+    // Last resort: just the mandatory block
+    return MANDATORY_BLOCK;
+}
+// ─── Handler (subtask 2.4) ───────────────────────────────────────────────────
+/**
+ * Main handler for the hook-session-start CLI command.
+ *
+ * Returns the JSON string to write to stdout, or null for silent exit.
+ * Never throws — any error → null (fail-safe pass-through).
+ */
+export async function handleSessionStart(opts) {
+    try {
+        if (!opts.sessionStartConfig.enabled) {
+            return null;
+        }
+        const agents = await scanAgents(opts.projectRoot, opts.homeDir);
+        let message = buildReminderMessage(agents, opts.sessionStartConfig.maxReminderTokens);
+        // TP-340: surface a fresh snapshot so the new session can resume.
+        const snap = await loadLatestSnapshot(opts.projectRoot);
+        if (snap && snap.ageMs < SNAPSHOT_FRESH_MS) {
+            const minutes = Math.round(snap.ageMs / 60000);
+            const age = minutes < 60 ? `${minutes}m ago` : `${Math.round(minutes / 60)}h ago`;
+            const goal = extractSnapshotGoal(snap.body);
+            const goalClause = goal ? ` (goal: "${goal}")` : "";
+            message += `\n\n[token-pilot] session_snapshot from ${age}${goalClause}. Read .token-pilot/snapshots/latest.md to resume — or ignore if unrelated.`;
+        }
+        const output = {
+            hookSpecificOutput: {
+                hookEventName: "SessionStart",
+                additionalContext: message,
+            },
+        };
+        return JSON.stringify(output);
+    }
+    catch {
+        // Fail-safe: never block the session
+        return null;
+    }
+}
+//# sourceMappingURL=session-start.js.map

package/dist/hooks/summary-ast-index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Primary hook-summary parser: spawns the bundled `ast-index` binary with
+ * `ast-index outline <path>` and maps the returned outline entries to
+ * SignalLine[]. Returns null when the binary is unavailable or the
+ * subprocess fails — the pipeline then falls back to regex / head+tail.
+ *
+ * Short-lived: the hook process spawns the binary once per invocation.
+ * The long-running AstIndexClient used by the MCP server is intentionally
+ * NOT reused here to keep the hook's startup cost minimal.
+ */
+import type { HookSummary } from "./summary-types.js";
+type ExecFn = (binary: string, args: string[], opts: {
+    timeout: number;
+}) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export interface AstIndexSummaryOptions {
+    /** Explicit binary path. `null` means "no binary available" → returns null. Omit to resolve via findBinary. */
+    binaryPath?: string | null;
+    /** Subprocess timeout (ms). Default 4000. */
+    timeoutMs?: number;
+    /** Injectable spawner for tests. */
+    exec?: ExecFn;
+}
+export declare function parseAstIndexSummary(content: string, filePath: string, options?: AstIndexSummaryOptions): Promise<HookSummary | null>;
+export {};
+//# sourceMappingURL=summary-ast-index.d.ts.map

package/dist/hooks/summary-ast-index.js

@@ -0,0 +1,122 @@
+/**
+ * Primary hook-summary parser: spawns the bundled `ast-index` binary with
+ * `ast-index outline <path>` and maps the returned outline entries to
+ * SignalLine[]. Returns null when the binary is unavailable or the
+ * subprocess fails — the pipeline then falls back to regex / head+tail.
+ *
+ * Short-lived: the hook process spawns the binary once per invocation.
+ * The long-running AstIndexClient used by the MCP server is intentionally
+ * NOT reused here to keep the hook's startup cost minimal.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { findBinary } from "../ast-index/binary-manager.js";
+import { parseOutlineText } from "../ast-index/parser.js";
+const execFileAsync = promisify(execFile);
+const DEFAULT_TIMEOUT_MS = 4000;
+const MAX_TEXT_LEN = 140;
+function extractExtension(filePath) {
+    const lastDot = filePath.lastIndexOf(".");
+    if (lastDot === -1 || lastDot === filePath.length - 1)
+        return "";
+    const ext = filePath.slice(lastDot + 1).toLowerCase();
+    if (ext.includes("/") || ext.includes("\\"))
+        return "";
+    return ext;
+}
+function truncate(text) {
+    const trimmed = text.trim();
+    if (trimmed.length <= MAX_TEXT_LEN)
+        return trimmed;
+    return trimmed.slice(0, MAX_TEXT_LEN - 1) + "…";
+}
+function estimateTokens(text) {
+    if (text.length === 0)
+        return 0;
+    const charEstimate = Math.ceil(text.length / 4);
+    const whitespaceRatio = (text.match(/\s/g)?.length ?? 0) / text.length;
+    const adjustment = 1 - whitespaceRatio * 0.3;
+    return Math.ceil(charEstimate * adjustment);
+}
+const defaultExec = async (binary, args, opts) => {
+    const { stdout, stderr } = await execFileAsync(binary, args, {
+        timeout: opts.timeout,
+    });
+    return { stdout: String(stdout), stderr: String(stderr) };
+};
+/**
+ * Resolve the binary path unless the caller already supplied one (including
+ * `null` to force "not available" for tests).
+ */
+async function resolveBinaryPath(explicit) {
+    if (explicit !== undefined)
+        return explicit;
+    try {
+        const status = await findBinary(null);
+        return status?.available ? status.path : null;
+    }
+    catch {
+        return null;
+    }
+}
+function flattenEntries(entries) {
+    const signals = [];
+    function walk(entry, depth) {
+        const indent = depth > 0 ? "  ".repeat(depth) : "";
+        const label = entry.signature && entry.signature.length > 0
+            ? entry.signature
+            : entry.name;
+        const text = truncate(`${indent}${entry.kind} ${label}`);
+        signals.push({
+            line: entry.start_line,
+            kind: entry.visibility === "public" ? "export" : "declaration",
+            text,
+        });
+        if (entry.children && entry.children.length > 0) {
+            for (const child of entry.children)
+                walk(child, depth + 1);
+        }
+    }
+    for (const entry of entries)
+        walk(entry, 0);
+    return signals;
+}
+export async function parseAstIndexSummary(content, filePath, options = {}) {
+    const binaryPath = await resolveBinaryPath(options.binaryPath);
+    if (!binaryPath)
+        return null;
+    const exec = options.exec ?? defaultExec;
+    const timeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    let outlineText;
+    try {
+        const { stdout } = await exec(binaryPath, ["outline", filePath], {
+            timeout,
+        });
+        outlineText = stdout;
+    }
+    catch {
+        return null;
+    }
+    let entries;
+    try {
+        entries = parseOutlineText(outlineText);
+    }
+    catch {
+        return null;
+    }
+    if (!entries || entries.length === 0)
+        return null;
+    const signals = flattenEntries(entries);
+    if (signals.length === 0)
+        return null;
+    const language = extractExtension(filePath);
+    const totalLines = content.split("\n").length;
+    const estimatedTokens = estimateTokens(content);
+    return {
+        signals,
+        totalLines,
+        estimatedTokens,
+        language,
+    };
+}
+//# sourceMappingURL=summary-ast-index.js.map

package/dist/hooks/summary-head-tail.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Last-resort head+tail summary.
+ *
+ * When both ast-index and the regex parser fail (crashed, unsupported language,
+ * malformed content), we still owe the caller *something* that respects the
+ * summary shape. This module produces a degraded HookSummary showing the first
+ * HEAD_LINES and last TAIL_LINES of the file as raw text, tagged with a note
+ * so the formatter can explain to the reader why the output is coarse.
+ *
+ * The function is intentionally total: empty input, unicode-heavy input, and
+ * absurdly large input all return a well-formed summary without throwing.
+ */
+import type { HookSummary } from "./summary-types.js";
+export declare function parseHeadTailSummary(content: string, filePath: string): HookSummary;
+//# sourceMappingURL=summary-head-tail.d.ts.map

package/dist/hooks/summary-head-tail.js

@@ -0,0 +1,78 @@
+/**
+ * Last-resort head+tail summary.
+ *
+ * When both ast-index and the regex parser fail (crashed, unsupported language,
+ * malformed content), we still owe the caller *something* that respects the
+ * summary shape. This module produces a degraded HookSummary showing the first
+ * HEAD_LINES and last TAIL_LINES of the file as raw text, tagged with a note
+ * so the formatter can explain to the reader why the output is coarse.
+ *
+ * The function is intentionally total: empty input, unicode-heavy input, and
+ * absurdly large input all return a well-formed summary without throwing.
+ */
+const HEAD_LINES = 40;
+const TAIL_LINES = 20;
+const MAX_TEXT_LEN = 140;
+function extractExtension(filePath) {
+    const lastDot = filePath.lastIndexOf(".");
+    if (lastDot === -1 || lastDot === filePath.length - 1)
+        return "";
+    const ext = filePath.slice(lastDot + 1).toLowerCase();
+    if (ext.includes("/") || ext.includes("\\"))
+        return "";
+    return ext;
+}
+function truncate(text) {
+    const trimmed = text.trimEnd();
+    if (trimmed.length <= MAX_TEXT_LEN)
+        return trimmed;
+    return trimmed.slice(0, MAX_TEXT_LEN - 1) + "…";
+}
+function estimateTokens(text) {
+    if (text.length === 0)
+        return 0;
+    const charEstimate = Math.ceil(text.length / 4);
+    const whitespaceRatio = (text.match(/\s/g)?.length ?? 0) / text.length;
+    const adjustment = 1 - whitespaceRatio * 0.3;
+    return Math.ceil(charEstimate * adjustment);
+}
+export function parseHeadTailSummary(content, filePath) {
+    const lines = content.split("\n");
+    const totalLines = lines.length;
+    const language = extractExtension(filePath);
+    const estimatedTokens = estimateTokens(content);
+    // When the file fits within HEAD_LINES + TAIL_LINES we include everything
+    // and omit the degradation note — no truncation actually happened.
+    if (totalLines <= HEAD_LINES + TAIL_LINES) {
+        const signals = lines.map((line, i) => ({
+            line: i + 1,
+            kind: "raw",
+            text: truncate(line),
+        }));
+        return {
+            signals,
+            totalLines,
+            estimatedTokens,
+            language,
+        };
+    }
+    const head = lines.slice(0, HEAD_LINES).map((line, i) => ({
+        line: i + 1,
+        kind: "raw",
+        text: truncate(line),
+    }));
+    const tailStart = totalLines - TAIL_LINES;
+    const tail = lines.slice(tailStart).map((line, i) => ({
+        line: tailStart + i + 1,
+        kind: "raw",
+        text: truncate(line),
+    }));
+    return {
+        signals: [...head, ...tail],
+        totalLines,
+        estimatedTokens,
+        language,
+        note: `parser unavailable — showing head+tail (first ${HEAD_LINES} and last ${TAIL_LINES} lines of ${totalLines})`,
+    };
+}
+//# sourceMappingURL=summary-head-tail.js.map

package/dist/hooks/summary-pipeline.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Summary-generation pipeline for the deny-enhanced hook.
+ *
+ * Tries three parsers in order — ast-index subprocess → regex → head+tail —
+ * and returns the first result with non-empty signals. If every parser
+ * fails to produce useful output (or throws), the pipeline reports
+ * `pass-through`, at which point the handler lets the original Read
+ * proceed unmodified rather than emitting an empty / misleading denial.
+ *
+ * Each parser is injectable for tests. The default wiring uses the
+ * real implementations from sibling modules.
+ */
+import type { HookSummary } from "./summary-types.js";
+export type PipelineTier = "ast-index" | "regex" | "head-tail";
+export type PipelineResult = {
+    kind: "summary";
+    summary: HookSummary;
+    tier: PipelineTier;
+} | {
+    kind: "pass-through";
+    reason: string;
+};
+type AstIndexFn = (content: string, filePath: string) => Promise<HookSummary | null>;
+type SyncSummaryFn = (content: string, filePath: string) => HookSummary;
+export interface PipelineOptions {
+    /** Primary parser — ast-index subprocess. Returns null on soft fail. */
+    astIndex?: AstIndexFn;
+    /** Fallback parser — regex. Expected to always return a HookSummary. */
+    regex?: SyncSummaryFn;
+    /** Last-resort parser — head+tail. Expected to always return a HookSummary. */
+    headTail?: SyncSummaryFn;
+}
+export declare function runSummaryPipeline(content: string, filePath: string, options?: PipelineOptions): Promise<PipelineResult>;
+export {};
+//# sourceMappingURL=summary-pipeline.d.ts.map

package/dist/hooks/summary-pipeline.js

@@ -0,0 +1,63 @@
+/**
+ * Summary-generation pipeline for the deny-enhanced hook.
+ *
+ * Tries three parsers in order — ast-index subprocess → regex → head+tail —
+ * and returns the first result with non-empty signals. If every parser
+ * fails to produce useful output (or throws), the pipeline reports
+ * `pass-through`, at which point the handler lets the original Read
+ * proceed unmodified rather than emitting an empty / misleading denial.
+ *
+ * Each parser is injectable for tests. The default wiring uses the
+ * real implementations from sibling modules.
+ */
+import { parseAstIndexSummary } from "./summary-ast-index.js";
+import { parseRegexSummary } from "./summary-regex.js";
+import { parseHeadTailSummary } from "./summary-head-tail.js";
+const defaultAstIndex = async (content, filePath) => parseAstIndexSummary(content, filePath);
+const defaultRegex = parseRegexSummary;
+const defaultHeadTail = parseHeadTailSummary;
+function hasSignals(summary) {
+    return !!summary && summary.signals.length > 0;
+}
+async function tryAsync(fn) {
+    try {
+        return await fn();
+    }
+    catch {
+        return null;
+    }
+}
+function trySync(fn) {
+    try {
+        return fn();
+    }
+    catch {
+        return null;
+    }
+}
+export async function runSummaryPipeline(content, filePath, options = {}) {
+    const astIndex = options.astIndex ?? defaultAstIndex;
+    const regex = options.regex ?? defaultRegex;
+    const headTail = options.headTail ?? defaultHeadTail;
+    // Tier 1 — ast-index. Soft-fails on null or throw.
+    const astResult = await tryAsync(() => astIndex(content, filePath));
+    if (hasSignals(astResult)) {
+        return { kind: "summary", summary: astResult, tier: "ast-index" };
+    }
+    // Tier 2 — regex. Empty signals means "nothing useful here, try next".
+    const regexResult = trySync(() => regex(content, filePath));
+    if (hasSignals(regexResult)) {
+        return { kind: "summary", summary: regexResult, tier: "regex" };
+    }
+    // Tier 3 — head+tail. Always produces *something*, unless the parser
+    // itself crashes (in which case we pass-through).
+    const headTailResult = trySync(() => headTail(content, filePath));
+    if (hasSignals(headTailResult)) {
+        return { kind: "summary", summary: headTailResult, tier: "head-tail" };
+    }
+    return {
+        kind: "pass-through",
+        reason: "all parsers returned empty or threw",
+    };
+}
+//# sourceMappingURL=summary-pipeline.js.map

package/dist/hooks/summary-regex.d.ts

@@ -0,0 +1,14 @@
+/**
+ * In-process regex-based structural summary parser.
+ *
+ * Fallback when the bundled ast-index binary is unavailable. Intentionally
+ * coarse: extracts imports, exports, and major top-level declarations per
+ * language using line-oriented regex. Never throws — worst case returns
+ * empty signals.
+ *
+ * Used by the hook summary pipeline (Phase 1 subtask 1.6).
+ */
+import type { HookSummary, SignalKind, SignalLine } from "./summary-types.js";
+export type { HookSummary, SignalKind, SignalLine };
+export declare function parseRegexSummary(content: string, filePath: string): HookSummary;
+//# sourceMappingURL=summary-regex.d.ts.map

package/dist/hooks/summary-regex.js

@@ -0,0 +1,130 @@
+/**
+ * In-process regex-based structural summary parser.
+ *
+ * Fallback when the bundled ast-index binary is unavailable. Intentionally
+ * coarse: extracts imports, exports, and major top-level declarations per
+ * language using line-oriented regex. Never throws — worst case returns
+ * empty signals.
+ *
+ * Used by the hook summary pipeline (Phase 1 subtask 1.6).
+ */
+const MAX_TEXT_LEN = 140;
+const EXTENSIONS = {
+    ts: tsJsPattern(),
+    tsx: tsJsPattern(),
+    js: tsJsPattern(),
+    jsx: tsJsPattern(),
+    mjs: tsJsPattern(),
+    cjs: tsJsPattern(),
+    py: pythonPattern(),
+    go: goPattern(),
+    rs: rustPattern(),
+};
+function tsJsPattern() {
+    return {
+        // Covers ES modules and CommonJS: `import ...`, `const x = require(...)`
+        import: /^\s*(import\s|const\s+\w+\s*=\s*require\s*\()/,
+        // export keyword, module.exports, exports.foo =
+        export: /^\s*(export\s|module\.exports\s*=|exports\.\w+\s*=)/,
+        // top-level declarations not prefixed with export — function/class/interface/type/enum
+        declaration: /^\s*(async\s+)?(function|class|interface|type|enum)\s+\w+/,
+    };
+}
+function pythonPattern() {
+    return {
+        import: /^\s*(import\s|from\s+\S+\s+import\s)/,
+        declaration: /^\s*(async\s+)?(def\s+\w+|class\s+\w+)/,
+    };
+}
+function goPattern() {
+    return {
+        import: /^\s*import\s/,
+        declaration: /^\s*(func\s|type\s+\w+\s+(struct|interface|func))/,
+    };
+}
+function rustPattern() {
+    return {
+        import: /^\s*use\s/,
+        export: /^\s*pub\s+(fn|struct|trait|enum|type|mod|const|static)\s/,
+        declaration: /^\s*(async\s+)?(fn|struct|trait|enum|type|mod)\s+\w+/,
+    };
+}
+/**
+ * Derive the lower-case extension for a file path.
+ * Returns an empty string if the path has no dot.
+ */
+function extractExtension(filePath) {
+    const lastDot = filePath.lastIndexOf(".");
+    if (lastDot === -1 || lastDot === filePath.length - 1)
+        return "";
+    const ext = filePath.slice(lastDot + 1).toLowerCase();
+    // Guard against extensions containing path separators (e.g., "/foo.d/bar").
+    if (ext.includes("/") || ext.includes("\\"))
+        return "";
+    return ext;
+}
+function truncate(text) {
+    const trimmed = text.trim();
+    if (trimmed.length <= MAX_TEXT_LEN)
+        return trimmed;
+    return trimmed.slice(0, MAX_TEXT_LEN - 1) + "…";
+}
+/**
+ * Very rough token estimate mirroring the project-wide heuristic
+ * (see src/core/token-estimator.ts). Duplicated here to avoid a hard
+ * dependency in the hook hot-path.
+ */
+function estimateTokens(text) {
+    if (text.length === 0)
+        return 0;
+    const charEstimate = Math.ceil(text.length / 4);
+    const whitespaceRatio = (text.match(/\s/g)?.length ?? 0) / text.length;
+    const adjustment = 1 - whitespaceRatio * 0.3;
+    return Math.ceil(charEstimate * adjustment);
+}
+export function parseRegexSummary(content, filePath) {
+    const language = extractExtension(filePath);
+    const totalLines = content.split("\n").length;
+    const estimatedTokens = estimateTokens(content);
+    const patterns = EXTENSIONS[language];
+    if (!patterns) {
+        return {
+            signals: [],
+            totalLines,
+            estimatedTokens,
+            language,
+        };
+    }
+    const lines = content.split("\n");
+    const signals = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line || line.trim().length === 0)
+            continue;
+        // Classification order: import → export → declaration. First match wins.
+        let kind = null;
+        if (patterns.import?.test(line)) {
+            kind = "import";
+        }
+        else if (patterns.export?.test(line)) {
+            kind = "export";
+        }
+        else if (patterns.declaration?.test(line)) {
+            kind = "declaration";
+        }
+        if (kind !== null) {
+            signals.push({
+                line: i + 1,
+                kind,
+                text: truncate(line),
+            });
+        }
+    }
+    return {
+        signals,
+        totalLines,
+        estimatedTokens,
+        language,
+    };
+}
+//# sourceMappingURL=summary-regex.js.map