token-pilot 0.19.2 → 0.23.0

package/dist/hooks/post-task.d.ts

@@ -0,0 +1,67 @@
+/**
+ * TP-q33(a) — PostToolUse:Task budget enforcement.
+ *
+ * Claude Code's `Task` tool is how subagents are dispatched. When one
+ * returns, this hook:
+ *   1. Identifies the subagent by `tool_input.subagent_type`.
+ *   2. Loads its agent markdown (project first, then ~/.claude/agents).
+ *   3. Reads the `Response budget: ~N tokens` line from the body.
+ *   4. Counts tokens in the `tool_response` body (chars/4 heuristic).
+ *   5. If actual > budget × (1 + OVER_BUDGET_TOLERANCE), append a JSONL
+ *      entry to `.token-pilot/over-budget.log`.
+ *
+ * Silent on every failure — telemetry must never break the agent loop.
+ * Non-tp-* subagents are ignored (we only enforce our own contracts).
+ */
+export declare const OVER_BUDGET_LOG = "over-budget.log";
+/** Ratio above which we flag — 0.1 = 10 % grace. */
+export declare const OVER_BUDGET_TOLERANCE = 0.1;
+export declare function parseAgentBudget(body: string): number | null;
+/**
+ * Count approx tokens in the `tool_response.content[*].text` blocks of a
+ * PostToolUse hook input for the Task tool. Returns null for anything
+ * other than a well-formed Task response.
+ */
+export declare function extractSubagentTokens(input: {
+    tool_name?: string;
+    tool_response?: unknown;
+}): number | null;
+export interface BudgetDecisionInput {
+    agentName: string;
+    budget: number | null;
+    actualTokens: number;
+}
+export interface BudgetDecisionResult {
+    overBudget: boolean;
+    overByRatio: number;
+    message: string | null;
+}
+export declare function decideBudgetAdvice(input: BudgetDecisionInput): BudgetDecisionResult;
+export interface OverBudgetEntry {
+    ts: number;
+    agent: string;
+    budget: number;
+    actualTokens: number;
+    overByRatio: number;
+}
+export declare function appendOverBudgetLog(projectRoot: string, entry: OverBudgetEntry): Promise<void>;
+/**
+ * Locate the markdown body for a `tp-*` subagent — project-level first,
+ * then user-level. Returns null when neither exists. Non-tp-* subagents
+ * are rejected up front so we never peek outside our namespace.
+ */
+export declare function loadAgentBody(projectRoot: string, homeDir: string, agentName: string): Promise<string | null>;
+export interface PostTaskHookInput {
+    tool_name?: string;
+    tool_input?: {
+        subagent_type?: string;
+    };
+    tool_response?: unknown;
+}
+/**
+ * Full post-Task processing: read frontmatter, count tokens, log over-budget.
+ * Returns the advice message (or null) so the caller can optionally emit
+ * `additionalContext` — though the primary output channel is the log file.
+ */
+export declare function processPostTask(projectRoot: string, homeDir: string, input: PostTaskHookInput): Promise<string | null>;
+//# sourceMappingURL=post-task.d.ts.map

package/dist/hooks/post-task.js

@@ -0,0 +1,136 @@
+/**
+ * TP-q33(a) — PostToolUse:Task budget enforcement.
+ *
+ * Claude Code's `Task` tool is how subagents are dispatched. When one
+ * returns, this hook:
+ *   1. Identifies the subagent by `tool_input.subagent_type`.
+ *   2. Loads its agent markdown (project first, then ~/.claude/agents).
+ *   3. Reads the `Response budget: ~N tokens` line from the body.
+ *   4. Counts tokens in the `tool_response` body (chars/4 heuristic).
+ *   5. If actual > budget × (1 + OVER_BUDGET_TOLERANCE), append a JSONL
+ *      entry to `.token-pilot/over-budget.log`.
+ *
+ * Silent on every failure — telemetry must never break the agent loop.
+ * Non-tp-* subagents are ignored (we only enforce our own contracts).
+ */
+import { promises as fs } from "node:fs";
+import { join } from "node:path";
+export const OVER_BUDGET_LOG = "over-budget.log";
+/** Ratio above which we flag — 0.1 = 10 % grace. */
+export const OVER_BUDGET_TOLERANCE = 0.1;
+const BUDGET_RE = /Response budget:\s*~?\s*(\d{2,6})\s*tokens?/i;
+export function parseAgentBudget(body) {
+    const m = body.match(BUDGET_RE);
+    if (!m)
+        return null;
+    const n = Number.parseInt(m[1], 10);
+    return Number.isFinite(n) && n > 0 ? n : null;
+}
+/**
+ * Count approx tokens in the `tool_response.content[*].text` blocks of a
+ * PostToolUse hook input for the Task tool. Returns null for anything
+ * other than a well-formed Task response.
+ */
+export function extractSubagentTokens(input) {
+    if (input.tool_name !== "Task")
+        return null;
+    const resp = input.tool_response;
+    if (!resp || typeof resp !== "object")
+        return null;
+    const parts = Array.isArray(resp.content) ? resp.content : [];
+    let chars = 0;
+    for (const p of parts) {
+        if (typeof p?.text === "string")
+            chars += p.text.length;
+    }
+    if (chars === 0)
+        return null;
+    return Math.ceil(chars / 4);
+}
+export function decideBudgetAdvice(input) {
+    if (input.budget == null || input.budget <= 0) {
+        return { overBudget: false, overByRatio: 0, message: null };
+    }
+    const allowed = input.budget * (1 + OVER_BUDGET_TOLERANCE);
+    if (input.actualTokens <= allowed) {
+        return {
+            overBudget: false,
+            overByRatio: input.actualTokens / input.budget - 1,
+            message: null,
+        };
+    }
+    const ratio = input.actualTokens / input.budget - 1;
+    const pct = Math.round(ratio * 100);
+    return {
+        overBudget: true,
+        overByRatio: ratio,
+        message: `${input.agentName} exceeded budget (~${input.actualTokens} tokens vs budget ${input.budget}, +${pct}%). See .token-pilot/over-budget.log.`,
+    };
+}
+export async function appendOverBudgetLog(projectRoot, entry) {
+    try {
+        const dir = join(projectRoot, ".token-pilot");
+        await fs.mkdir(dir, { recursive: true });
+        const line = JSON.stringify(entry) + "\n";
+        await fs.appendFile(join(dir, OVER_BUDGET_LOG), line);
+    }
+    catch {
+        /* silent — logging must never break the hook */
+    }
+}
+/**
+ * Locate the markdown body for a `tp-*` subagent — project-level first,
+ * then user-level. Returns null when neither exists. Non-tp-* subagents
+ * are rejected up front so we never peek outside our namespace.
+ */
+export async function loadAgentBody(projectRoot, homeDir, agentName) {
+    if (!agentName.startsWith("tp-"))
+        return null;
+    const candidates = [
+        join(projectRoot, ".claude", "agents", `${agentName}.md`),
+        join(homeDir, ".claude", "agents", `${agentName}.md`),
+    ];
+    for (const p of candidates) {
+        try {
+            return await fs.readFile(p, "utf-8");
+        }
+        catch {
+            /* try next */
+        }
+    }
+    return null;
+}
+/**
+ * Full post-Task processing: read frontmatter, count tokens, log over-budget.
+ * Returns the advice message (or null) so the caller can optionally emit
+ * `additionalContext` — though the primary output channel is the log file.
+ */
+export async function processPostTask(projectRoot, homeDir, input) {
+    if (input.tool_name !== "Task")
+        return null;
+    const agentName = input.tool_input?.subagent_type;
+    if (typeof agentName !== "string" || !agentName.startsWith("tp-")) {
+        return null;
+    }
+    const actualTokens = extractSubagentTokens(input);
+    if (actualTokens == null)
+        return null;
+    const body = await loadAgentBody(projectRoot, homeDir, agentName);
+    const budget = body ? parseAgentBudget(body) : null;
+    const decision = decideBudgetAdvice({
+        agentName,
+        budget,
+        actualTokens,
+    });
+    if (decision.overBudget && budget != null) {
+        await appendOverBudgetLog(projectRoot, {
+            ts: Date.now(),
+            agent: agentName,
+            budget,
+            actualTokens,
+            overByRatio: decision.overByRatio,
+        });
+    }
+    return decision.message;
+}
+//# sourceMappingURL=post-task.js.map

package/dist/hooks/session-start.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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.
+ */
+export interface AgentEntry {
+    name: string;
+    description: string;
+}
+export interface SessionStartConfig {
+    enabled: boolean;
+    showStats: boolean;
+    maxReminderTokens: number;
+}
+export interface HandleSessionStartOptions {
+    projectRoot: string;
+    homeDir: string;
+    sessionStartConfig: SessionStartConfig;
+}
+/**
+ * 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 declare function scanAgents(projectRoot: string, homeDir: string): Promise<AgentEntry[]>;
+/**
+ * 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 declare function buildReminderMessage(agents: AgentEntry[], maxReminderTokens: number): string;
+/**
+ * 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 declare function handleSessionStart(opts: HandleSessionStartOptions): Promise<string | null>;
+//# sourceMappingURL=session-start.d.ts.map

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