@temet/cli 0.2.0 → 0.3.0

package/dist/audit.d.ts

@@ -0,0 +1,32 @@
+import { type AuditResult } from "./lib/session-audit.js";
+import { type AuditChange, type TrackingResult } from "./lib/audit-tracking.js";
+import type { CompetencyEntry } from "./lib/types.js";
+export type AuditOptions = {
+    path: string;
+    track: boolean;
+    narrate: boolean;
+    json: boolean;
+    quiet: boolean;
+    notify: boolean;
+    publish: boolean;
+    yes: boolean;
+    model: string;
+    address: string;
+    token: string;
+    relayUrl: string;
+};
+export declare function buildAuditJsonOutput(result: Pick<AuditResult, "sessionCount" | "messageCount" | "toolCallCount" | "workflows">, competencies: CompetencyEntry[], bilan?: string, tracking?: Pick<TrackingResult, "changes" | "latestPath">): {
+    tracking?: {
+        latestPath: string;
+        changes: AuditChange[];
+    } | undefined;
+    bilan?: string | undefined;
+    sessions: number;
+    messages: number;
+    toolCalls: number;
+    competencies: CompetencyEntry[];
+    workflows: import("./lib/workflow-detector.js").DetectedWorkflow[];
+};
+export declare function resolvePublishMode(yes: boolean, isTTY: boolean): "skip" | "reject" | "prompt";
+export declare function hasPublishCredentials(address: string, token: string): boolean;
+export declare function runAuditCommand(opts: AuditOptions): Promise<void>;

package/dist/audit.js

@@ -0,0 +1,460 @@
+/**
+ * temet audit — analyze your coding sessions, surface your real skills.
+ */
+import { basename } from "node:path";
+import { clearLine, createInterface, cursorTo } from "node:readline";
+import { findSessionFiles, runAudit, } from "./lib/session-audit.js";
+import { trackAuditSnapshot, } from "./lib/audit-tracking.js";
+export function buildAuditJsonOutput(result, competencies, bilan, tracking) {
+    return {
+        sessions: result.sessionCount,
+        messages: result.messageCount,
+        toolCalls: result.toolCallCount,
+        competencies,
+        workflows: result.workflows,
+        ...(bilan ? { bilan } : {}),
+        ...(tracking
+            ? {
+                tracking: {
+                    latestPath: tracking.latestPath,
+                    changes: tracking.changes,
+                },
+            }
+            : {}),
+    };
+}
+// ---------- Pretty Output ----------
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const CYAN = "\x1b[36m";
+const MAGENTA = "\x1b[35m";
+const BLUE = "\x1b[34m";
+const RED = "\x1b[31m";
+const SPINNER_FRAMES = ["-", "\\", "|", "/"];
+const TEMET_ASCII = [
+    "████████╗███████╗███╗   ███╗███████╗████████╗",
+    "╚══██╔══╝██╔════╝████╗ ████║██╔════╝╚══██╔══╝",
+    "   ██║   █████╗  ██╔████╔██║█████╗     ██║   ",
+    "   ██║   ██╔══╝  ██║╚██╔╝██║██╔══╝     ██║   ",
+    "   ██║   ███████╗██║ ╚═╝ ██║███████╗   ██║   ",
+    "   ╚═╝   ╚══════╝╚═╝     ╚═╝╚══════╝   ╚═╝   ",
+];
+function useAnsi(stream) {
+    return Boolean(stream.isTTY && !process.env.NO_COLOR);
+}
+function colorize(text, color, stream) {
+    if (!useAnsi(stream))
+        return text;
+    return `${color}${text}${RESET}`;
+}
+function dim(text, stream) {
+    if (!useAnsi(stream))
+        return text;
+    return `${DIM}${text}${RESET}`;
+}
+function ok(text, stream) {
+    return colorize(text, GREEN, stream);
+}
+function warn(text, stream) {
+    return colorize(text, YELLOW, stream);
+}
+function fail(text, stream) {
+    return colorize(text, RED, stream);
+}
+function clearCurrentLine(stream) {
+    if (!stream.isTTY)
+        return;
+    clearLine(stream, 0);
+    cursorTo(stream, 0);
+}
+function stepPrefix(step, totalSteps, stream) {
+    return colorize(`[${step}/${totalSteps}]`, BLUE, stream);
+}
+function formatCount(value) {
+    return value.toLocaleString("en-US");
+}
+function formatMs(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    return `${(ms / 1000).toFixed(2)}s`;
+}
+function printRule(stream) {
+    stream.write(`${dim("─".repeat(58), stream)}\n`);
+}
+function printWarningBox(message) {
+    const stream = process.stderr;
+    printRule(stream);
+    stream.write(`${warn("warning", stream)}  ${message}\n`);
+    printRule(stream);
+}
+function printBanner() {
+    const stream = process.stderr;
+    if (!stream.isTTY)
+        return;
+    for (const line of TEMET_ASCII) {
+        stream.write(`${colorize(line, CYAN, stream)}\n`);
+    }
+    stream.write(`\n${BOLD}Temet Audit${RESET}\n`);
+    printRule(stream);
+}
+function renderBar(current, total, width = 18) {
+    if (total <= 0)
+        return `[${"-".repeat(width)}]`;
+    const ratio = Math.max(0, Math.min(1, current / total));
+    const filled = Math.round(ratio * width);
+    return `${"█".repeat(filled)}${"░".repeat(width - filled)}`;
+}
+function truncateLabel(label, max = 28) {
+    if (label.length <= max)
+        return label;
+    return `${label.slice(0, max - 3)}...`;
+}
+function writeStepProgress(step, totalSteps, label, current, total, detail) {
+    const stream = process.stderr;
+    const percent = total > 0 ? `${Math.round((current / total) * 100)}%` : "0%";
+    const parts = [
+        stepPrefix(step, totalSteps, stream),
+        label,
+        dim(`${current}/${total}`, stream),
+        colorize(renderBar(current, total), CYAN, stream),
+        dim(percent, stream),
+    ];
+    if (detail) {
+        parts.push(dim(truncateLabel(detail), stream));
+    }
+    const line = parts.join("  ");
+    if (stream.isTTY) {
+        clearCurrentLine(stream);
+        stream.write(line);
+        return;
+    }
+    stream.write(`${line}\n`);
+}
+function writeStepDone(step, totalSteps, label, detail, elapsedMs) {
+    const stream = process.stderr;
+    const paddedLabel = label.padEnd(22);
+    const parts = [
+        stepPrefix(step, totalSteps, stream),
+        paddedLabel,
+        ok("done", stream),
+    ];
+    if (detail) {
+        parts.push(dim(detail, stream));
+    }
+    if (typeof elapsedMs === "number") {
+        parts.push(dim(`in ${formatMs(elapsedMs)}`, stream));
+    }
+    const line = parts.join("  ");
+    if (stream.isTTY) {
+        clearCurrentLine(stream);
+    }
+    stream.write(`${line}\n`);
+}
+async function withSpinner(step, totalSteps, label, task) {
+    const stream = process.stderr;
+    const startedAt = Date.now();
+    if (!stream.isTTY) {
+        stream.write(`${stepPrefix(step, totalSteps, stream)} ${label}...\n`);
+        const result = await task();
+        writeStepDone(step, totalSteps, label, undefined, Date.now() - startedAt);
+        return result;
+    }
+    let frameIndex = 0;
+    const timer = setInterval(() => {
+        clearCurrentLine(stream);
+        const frame = SPINNER_FRAMES[frameIndex % SPINNER_FRAMES.length];
+        frameIndex += 1;
+        stream.write(`${stepPrefix(step, totalSteps, stream)} ${label}  ${colorize(frame, CYAN, stream)}`);
+    }, 80);
+    try {
+        const result = await task();
+        clearInterval(timer);
+        writeStepDone(step, totalSteps, label, undefined, Date.now() - startedAt);
+        return result;
+    }
+    catch (error) {
+        clearInterval(timer);
+        clearCurrentLine(stream);
+        stream.write(`${stepPrefix(step, totalSteps, stream)} ${label.padEnd(22)}  ${fail("failed", stream)}\n`);
+        throw error;
+    }
+}
+const PROF_COLOR = {
+    expert: "\x1b[32m",
+    proficient: "\x1b[33m",
+    competent: "\x1b[36m",
+    advanced_beginner: "\x1b[34m",
+    novice: "\x1b[37m",
+};
+function profLabel(level) {
+    const color = PROF_COLOR[level] ?? "";
+    return `${color}${level.replace("_", " ")}${RESET}`;
+}
+function printPretty(result, competencies, bilan, tracking) {
+    console.log("");
+    console.log(`${dim(`${formatCount(result.sessionCount)} sessions · ${formatCount(result.toolCallCount)} tool calls · ${formatCount(competencies.length)} skills · ${formatCount(result.workflowCount)} workflows`, process.stdout)}`);
+    console.log("");
+    // Top skills
+    const sorted = [...competencies].sort((a, b) => {
+        const order = [
+            "expert",
+            "proficient",
+            "competent",
+            "advanced_beginner",
+            "novice",
+        ];
+        return (order.indexOf(a.proficiencyLevel) - order.indexOf(b.proficiencyLevel));
+    });
+    const topSkills = sorted.slice(0, 8);
+    console.log(`${BOLD}${GREEN}Skills you already demonstrate${RESET}`);
+    for (const c of topSkills) {
+        console.log(`  ${profLabel(c.proficiencyLevel)}  ${c.name}`);
+    }
+    console.log("");
+    // Repeated patterns
+    console.log(`${BOLD}${CYAN}Repeated patterns${RESET}`);
+    if (result.workflows.length > 0) {
+        for (const w of result.workflows.slice(0, 5)) {
+            console.log(`  ${w.description} ${DIM}(${w.occurrences}x across ${w.sessions} sessions)${RESET}`);
+        }
+    }
+    else {
+        console.log(`  ${DIM}0 workflows detected${RESET}`);
+    }
+    console.log("");
+    // Judgment signals
+    const judgmentSignals = result.signals.filter((s) => s.type === "correction" || s.type === "decision_language");
+    if (judgmentSignals.length > 0) {
+        console.log(`${BOLD}${MAGENTA}Your decisions${RESET}`);
+        const seen = new Set();
+        for (const s of judgmentSignals) {
+            const key = s.skill;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            if (seen.size > 5)
+                break;
+            const verb = s.type === "correction" ? "You correct for" : "You prioritize";
+            console.log(`  ${verb} ${s.skill}`);
+        }
+        console.log("");
+    }
+    if (tracking) {
+        console.log(`${BOLD}${BLUE}Meaningful changes${RESET}`);
+        if (tracking.changes.length > 0) {
+            for (const change of tracking.changes) {
+                const marker = change.type === "level_down"
+                    ? warn("↓", process.stdout)
+                    : change.type === "baseline"
+                        ? colorize("•", CYAN, process.stdout)
+                        : ok("↑", process.stdout);
+                console.log(`  ${marker} ${change.title}`);
+                console.log(`    ${DIM}${change.detail}${RESET}`);
+            }
+        }
+        else {
+            console.log(`  ${DIM}No meaningful changes since the last tracked audit${RESET}`);
+        }
+        console.log("");
+    }
+    // Bilan from narrator
+    if (bilan) {
+        console.log(`${BOLD}${YELLOW}Profile summary${RESET}`);
+        console.log("");
+        console.log(bilan);
+        console.log("");
+    }
+    // Next actions
+    console.log(`${dim("─".repeat(44), process.stdout)}`);
+    console.log(`${BOLD}Next${RESET}`);
+    if (!tracking) {
+        console.log(`  ${DIM}temet audit --path <dir> --track${RESET}       Save a baseline and track changes`);
+    }
+    console.log(`  ${DIM}temet audit --path <dir> --json${RESET}        Export as JSON`);
+    console.log(`  ${DIM}temet audit --path <dir> --publish${RESET}     Publish to your Temet card`);
+    console.log("");
+    console.log(`${ok("Audit complete:", process.stdout)} ${formatCount(competencies.length)} skills surfaced from ${formatCount(result.sessionCount)} sessions`);
+    if (tracking) {
+        console.log(`${dim(`Snapshot saved to ${tracking.latestPath}`, process.stdout)}`);
+    }
+    console.log("");
+}
+// ---------- Confirmation ----------
+async function confirmPublish(competencyCount, address) {
+    // Non-interactive (piped stdin) → refuse without --yes
+    if (!process.stdin.isTTY) {
+        console.error("[temet] non-interactive mode: use --yes to confirm publish");
+        return false;
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    return new Promise((resolve) => {
+        rl.question(`\n${BOLD}Publish ${competencyCount} competencies to card ${address}?${RESET} [y/N] `, (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() === "y");
+        });
+    });
+}
+export function resolvePublishMode(yes, isTTY) {
+    if (yes)
+        return "skip";
+    if (!isTTY)
+        return "reject";
+    return "prompt";
+}
+export function hasPublishCredentials(address, token) {
+    return Boolean(address && token);
+}
+// ---------- Publish ----------
+async function publishCompetencies(competencies, opts) {
+    if (!hasPublishCredentials(opts.address, opts.token)) {
+        console.error("[temet] --publish requires TEMET_ADDRESS and TEMET_TOKEN env vars");
+        process.exit(1);
+    }
+    const url = `${opts.relayUrl}/ingest/${opts.address}`;
+    console.error(`[temet] publishing ${competencies.length} competencies to ${url}`);
+    const resp = await fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${opts.token}`,
+        },
+        body: JSON.stringify({ competencies }),
+    });
+    if (!resp.ok) {
+        const body = await resp.text();
+        console.error(`[temet] publish failed (${resp.status}): ${body}`);
+        process.exit(1);
+    }
+    const result = (await resp.json());
+    console.log("");
+    console.log(`${BOLD}${GREEN}Published!${RESET}`);
+    console.log(`  Skills: ${result.totalSkills}`);
+    console.log(`  Card version: ${result.cardVersion}`);
+    console.log(`  View: https://temetapp.com/a/${opts.address}`);
+    console.log("");
+}
+// ---------- Main ----------
+export async function runAuditCommand(opts) {
+    const sessionFiles = findSessionFiles(opts.path);
+    if (sessionFiles.length === 0) {
+        if (!opts.quiet) {
+            console.error(`[temet] no .jsonl session files found in ${opts.path}`);
+        }
+        process.exit(1);
+    }
+    if (!opts.json && !opts.quiet) {
+        printBanner();
+    }
+    if (!opts.quiet) {
+        console.error(`[temet] scanning ${sessionFiles.length} session file(s)...`);
+    }
+    const totalSteps = 3 + (opts.narrate ? 1 : 0) + (opts.publish ? 1 : 0);
+    let completedFiles = 0;
+    const commandStartedAt = Date.now();
+    if (!opts.quiet) {
+        writeStepProgress(1, totalSteps, "Scanning sessions", 0, sessionFiles.length);
+    }
+    let scanDoneWritten = false;
+    const result = await runAudit(sessionFiles, (event) => {
+        if (opts.quiet)
+            return;
+        if (event.phase === "scan") {
+            completedFiles += 1;
+            writeStepProgress(1, totalSteps, "Scanning sessions", completedFiles, sessionFiles.length, event.file ? basename(event.file) : undefined);
+            return;
+        }
+        if (!scanDoneWritten) {
+            scanDoneWritten = true;
+            writeStepDone(1, totalSteps, "Scanning sessions", `${sessionFiles.length} files`);
+        }
+        if (event.phase === "signals") {
+            writeStepDone(2, totalSteps, "Extracting signals", `${formatCount(event.current ?? 0)} signals`, event.elapsedMs);
+            return;
+        }
+        if (event.phase === "patterns") {
+            writeStepDone(3, totalSteps, "Detecting patterns", `${formatCount(event.current ?? 0)} workflows`, event.elapsedMs);
+        }
+    });
+    let { competencies } = result;
+    let bilan;
+    let tracking;
+    // Narrator enrichment
+    if (opts.narrate && !opts.quiet) {
+        try {
+            const narratorModule = await import("./lib/narrator-lite.js");
+            if (!narratorModule.resolveAuth()) {
+                printWarningBox("--narrate requires model access. Set ANTHROPIC_API_KEY or CLAUDE_AUTH_TOKEN.");
+            }
+            else {
+                const narrated = await withSpinner(4, totalSteps, "Narrating profile", async () => narratorModule.narrateCompetencies(competencies, result.combined, result.workflows, { model: opts.model || undefined }));
+                competencies = narrated.competencies;
+                bilan = narrated.bilan || undefined;
+            }
+        }
+        catch (err) {
+            console.error("[temet] narrator failed, using heuristic results:", err);
+        }
+    }
+    if (opts.track) {
+        tracking = await trackAuditSnapshot(opts.path, result, competencies);
+        // OS notification (only behind --notify, and only if something changed)
+        if (opts.notify && !tracking.skipped && tracking.changes.length > 0) {
+            const { formatNotification, sendNotification } = await import("./lib/notifier.js");
+            const payload = formatNotification(tracking.changes, tracking.current.projectLabel);
+            if (payload) {
+                void sendNotification(payload).catch(() => { });
+            }
+        }
+    }
+    // Publish (runs even in quiet mode — it's a side-effect, not output)
+    if (opts.publish) {
+        const publishMode = resolvePublishMode(opts.yes, Boolean(process.stdin.isTTY));
+        if (publishMode === "reject") {
+            if (!opts.quiet) {
+                printWarningBox("non-interactive mode: use --yes to confirm publish");
+            }
+            console.error("[temet] publish requires --yes in non-interactive mode");
+            process.exit(1);
+        }
+        else {
+            const confirmed = publishMode === "skip" ||
+                (await confirmPublish(competencies.length, opts.address));
+            if (confirmed) {
+                if (opts.quiet) {
+                    await publishCompetencies(competencies, {
+                        address: opts.address,
+                        token: opts.token,
+                        relayUrl: opts.relayUrl,
+                    });
+                }
+                else {
+                    await withSpinner(totalSteps, totalSteps, "Publishing card", () => publishCompetencies(competencies, {
+                        address: opts.address,
+                        token: opts.token,
+                        relayUrl: opts.relayUrl,
+                    }));
+                }
+            }
+            else if (!opts.quiet) {
+                console.error("[temet] publish cancelled");
+            }
+        }
+    }
+    // Quiet mode: no output
+    if (opts.quiet)
+        return;
+    // Output
+    if (opts.json) {
+        const output = buildAuditJsonOutput(result, competencies, bilan, tracking);
+        console.log(JSON.stringify(output, null, 2));
+    }
+    else {
+        printPretty(result, competencies, bilan, tracking);
+    }
+    if (!opts.json) {
+        console.error(`${ok("done", process.stderr)} ${dim(`in ${formatMs(Date.now() - commandStartedAt)}`, process.stderr)}`);
+    }
+}

package/dist/index.js

@@ -4,25 +4,42 @@ import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, resolve } from "node:path";
 import { promisify } from "node:util";
+import { buildAuditCliOptions, parseFlagBag, readOptionalString, } from "./lib/cli-args.js";
+import { resolveSessionPath } from "./lib/path-resolver.js";
 const execFileAsync = promisify(execFile);
 const DEFAULT_RELAY_URL = "https://temet-relay.ramponneau.workers.dev/mcp";
 const DEFAULT_SERVER_NAME = "temet";
 const DEFAULT_PROTOCOL_APP_NAME = "Temet Handler";
 const LINUX_DESKTOP_ENTRY = "temet-handler.desktop";
 const LINUX_HANDLER_SCRIPT = "temet-protocol-handler";
-const HELP = `Temet CLI
+const HELP = `Temet CLI — discover the skills you already demonstrate in AI work
 
-Usage:
-\ttemet connect --address <16hex> --token <token> [--config-path <path>] [--relay-url <url>] [--name temet] [--dry-run]
-\ttemet connect-url --url "temet://connect?address=<16hex>&token=<token>&relay=<url>&name=temet" [--config-path <path>] [--name temet] [--relay-url <url>] [--dry-run]
-\ttemet install-handler [--dry-run]
-\ttemet uninstall-handler [--dry-run]
+Commands:
+\ttemet audit [--path <session-dir>]        Analyze local sessions, surface skills and workflows
+\ttemet install-hook                        Auto-audit after every Claude Code session
+\ttemet uninstall-hook                      Remove the SessionEnd hook
+\ttemet connect --address <hex> --token <t> Connect your MCP client to your Temet card
+\ttemet install-handler                     Register temet:// protocol handler
+
+Audit options:
+\t--path <dir>     Directory containing .jsonl session files (auto-detected if omitted)
+\t--track          Save a local snapshot and compare against the previous audit
+\t--json           Output structured JSON instead of terminal display
+\t--quiet          Suppress all output (for background hooks)
+\t--notify         Send an OS notification on skill changes (used with --track)
+\t--publish        Publish results to your Temet card (requires confirmation)
+\t--yes, -y        Skip publish confirmation (for scripts/CI)
+
+Advanced:
+\t--narrate        Enrich results with an LLM (requires model access: ANTHROPIC_API_KEY or CLAUDE_AUTH_TOKEN)
+\t--model <id>     Model to use for narration (default: claude-haiku-4-5-20251001)
 
 Examples:
-\ttemet connect --address a3f8c2d19f0b7e41 --token <token>
-\ttemet connect-url --url "temet://connect?address=a3f8c2d19f0b7e41&token=<token>&relay=https%3A%2F%2Ftemet-relay.ramponneau.workers.dev%2Fmcp"
-\tpnpm dlx @temet/cli install-handler
-\tpnpm dlx @temet/cli connect-url --url "temet://connect?address=a3f8c2d19f0b7e41&token=<token>"
+\ttemet audit                                            Auto-detect sessions from cwd
+\ttemet audit --path ~/.claude/projects/my-project
+\ttemet audit --path ~/.claude/projects/my-project --track
+\ttemet audit --path ~/.claude/projects/my-project --json
+\ttemet install-hook                                     Background audit on session end
 `;
 function printHelp(exitCode = 0) {
     console.log(HELP);
@@ -38,36 +55,6 @@ function normalizeAddress(raw) {
     }
     return address;
 }
-function parseFlagBag(args) {
-    const flags = new Map();
-    const positionals = [];
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (!arg.startsWith("--")) {
-            positionals.push(arg);
-            continue;
-        }
-        if (arg === "--dry-run") {
-            flags.set("dry-run", true);
-            continue;
-        }
-        const key = arg.slice(2);
-        const value = args[i + 1];
-        if (!value || value.startsWith("--")) {
-            throw new Error(`Missing value for --${key}`);
-        }
-        flags.set(key, value);
-        i += 1;
-    }
-    return { flags, positionals };
-}
-function readOptionalString(flags, key) {
-    const value = flags.get(key);
-    if (typeof value !== "string")
-        return null;
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : null;
-}
 function parseConnectOptions(flags) {
     const address = normalizeAddress(String(flags.get("address") ?? ""));
     const token = String(flags.get("token") ?? "").trim();
@@ -156,6 +143,22 @@ function parseArgs(argv) {
     const [command, ...rest] = argv;
     const { flags, positionals } = parseFlagBag(rest);
     const dryRun = Boolean(flags.get("dry-run"));
+    if (command === "audit") {
+        const options = buildAuditCliOptions(flags, process.env);
+        if (!options.path) {
+            // Auto-detect session path
+            const detected = resolveSessionPath(undefined, process.env);
+            if (!detected) {
+                console.error("[temet] could not auto-detect session directory. Use --path <session-dir>");
+                process.exit(1);
+            }
+            options.path = detected;
+        }
+        return {
+            command,
+            options,
+        };
+    }
     if (command === "connect") {
         return {
             command,
@@ -171,6 +174,9 @@ function parseArgs(argv) {
     if (command === "install-handler" || command === "uninstall-handler") {
         return { command, dryRun };
     }
+    if (command === "install-hook" || command === "uninstall-hook") {
+        return { command, dryRun };
+    }
     console.error(`Unknown command: ${command}`);
     printHelp(1);
 }
@@ -491,10 +497,57 @@ async function uninstallProtocolHandler(dryRun) {
 }
 async function run() {
     const parsed = parseArgs(process.argv.slice(2));
+    if (parsed.command === "audit") {
+        const { runAuditCommand } = await import("./audit.js");
+        await runAuditCommand(parsed.options);
+        return;
+    }
     if (parsed.command === "connect" || parsed.command === "connect-url") {
         await runWriteFlow(parsed.command, parsed.options);
         return;
     }
+    if (parsed.command === "install-hook") {
+        const { resolveTemetBinary, readSettings, writeSettings, isHookInstalled, installHook, getSettingsPath, } = await import("./lib/hook-installer.js");
+        const settingsPath = getSettingsPath();
+        const settings = readSettings(settingsPath);
+        if (isHookInstalled(settings)) {
+            console.log("[temet] Hook already installed.");
+            return;
+        }
+        const binary = resolveTemetBinary();
+        if (!binary) {
+            console.error("[temet] Could not resolve temet binary. Install @temet/cli globally first: npm i -g @temet/cli");
+            process.exit(1);
+        }
+        if (parsed.dryRun) {
+            console.log(`[temet] dry-run: binary resolved to: ${binary}`);
+            console.log(`[temet] dry-run: would write to ${settingsPath}`);
+            return;
+        }
+        const updated = installHook(settings, binary);
+        writeSettings(settingsPath, updated);
+        console.log(`[temet] Resolved binary: ${binary}`);
+        console.log(`[temet] SessionEnd hook installed in ${settingsPath}`);
+        console.log("[temet] Restart Claude Code for the hook to take effect.");
+        return;
+    }
+    if (parsed.command === "uninstall-hook") {
+        const { readSettings, writeSettings, isHookInstalled, uninstallHook, getSettingsPath, } = await import("./lib/hook-installer.js");
+        const settingsPath = getSettingsPath();
+        const settings = readSettings(settingsPath);
+        if (!isHookInstalled(settings)) {
+            console.log("[temet] No hook installed.");
+            return;
+        }
+        if (parsed.dryRun) {
+            console.log(`[temet] dry-run: would remove hook from ${settingsPath}`);
+            return;
+        }
+        const updated = uninstallHook(settings);
+        writeSettings(settingsPath, updated);
+        console.log("[temet] SessionEnd hook removed.");
+        return;
+    }
     if (parsed.command === "install-handler") {
         await installProtocolHandler(parsed.dryRun);
         console.log("[temet] next: click a Quick connect button in Temet.");

package/dist/lib/analysis-types.d.ts

@@ -0,0 +1,7 @@
+import type { SessionMessage, ToolCall } from "./session-parser.js";
+export type CombinedStats = {
+    messages: SessionMessage[];
+    toolCalls: ToolCall[];
+    filesTouched: string[];
+    allToolCallsBySession: ToolCall[][];
+};

package/dist/lib/analysis-types.js

@@ -0,0 +1 @@
+export {};