@temet/cli 0.2.0 → 0.3.1

package/dist/audit.d.ts

@@ -0,0 +1,34 @@
+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;
+    openReport: 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" | "promptCount" | "toolCallCount" | "workflows">, competencies: CompetencyEntry[], bilan?: string, tracking?: Pick<TrackingResult, "changes" | "latestPath">): {
+    tracking?: {
+        latestPath: string;
+        changes: AuditChange[];
+    } | undefined;
+    bilan?: string | undefined;
+    sessions: number;
+    messages: number;
+    prompts: 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,531 @@
+/**
+ * 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 { resolveSessionPath, } from "./lib/path-resolver.js";
+import { trackAuditSnapshot, } from "./lib/audit-tracking.js";
+export function buildAuditJsonOutput(result, competencies, bilan, tracking) {
+    return {
+        sessions: result.sessionCount,
+        messages: result.messageCount,
+        prompts: result.promptCount,
+        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");
+        });
+    });
+}
+async function chooseSessionCandidate(candidates) {
+    if (!process.stdin.isTTY || candidates.length === 0)
+        return null;
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    process.stderr.write(`\n[temet] I found ${candidates.length} Claude projects. Which one should I audit?\n\n`);
+    candidates.slice(0, 9).forEach((candidate, index) => {
+        process.stderr.write(`  ${index + 1}. ${candidate.label}${index === 0 ? "  (most recent)" : ""}\n`);
+    });
+    process.stderr.write("\n");
+    return new Promise((resolve) => {
+        rl.question("[temet] Choose a project [1-9] or press Enter for the most recent: ", (answer) => {
+            rl.close();
+            const trimmed = answer.trim();
+            if (!trimmed) {
+                resolve(candidates[0] ?? null);
+                return;
+            }
+            const index = Number.parseInt(trimmed, 10) - 1;
+            if (!Number.isFinite(index) ||
+                index < 0 ||
+                index >= candidates.length) {
+                resolve(candidates[0] ?? null);
+                return;
+            }
+            resolve(candidates[index] ?? null);
+        });
+    });
+}
+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 totalSteps = 4 + (opts.narrate ? 1 : 0) + (opts.publish ? 1 : 0);
+    const commandStartedAt = Date.now();
+    let resolvedPath = opts.path;
+    if (!opts.quiet) {
+        const resolution = await withSpinner(1, totalSteps, "Discovering sessions", async () => resolveSessionPath(opts.path || undefined, process.env));
+        if (!resolution.path) {
+            console.error("[temet] no Claude sessions found. Run this command from a project folder, or use --path <session-dir>.");
+            process.exit(1);
+        }
+        if (!opts.path &&
+            !opts.json &&
+            resolution.source === "recent" &&
+            resolution.candidates.length > 1) {
+            const selected = await chooseSessionCandidate(resolution.candidates);
+            resolvedPath = selected?.sessionDir ?? resolution.path;
+            const label = selected?.label ?? resolution.candidates[0]?.label;
+            if (label) {
+                process.stderr.write(`${dim(`[temet] using ${label}`, process.stderr)}\n`);
+            }
+        }
+        else {
+            resolvedPath = resolution.path;
+            const label = resolution.candidates[0]?.label;
+            if (label && resolution.source !== "explicit") {
+                process.stderr.write(`${dim(`[temet] using ${label}`, process.stderr)}\n`);
+            }
+        }
+    }
+    else {
+        const resolution = resolveSessionPath(opts.path || undefined, process.env);
+        if (!resolution.path) {
+            process.exit(1);
+        }
+        resolvedPath = resolution.path;
+    }
+    const sessionFiles = findSessionFiles(resolvedPath);
+    if (sessionFiles.length === 0) {
+        if (!opts.quiet) {
+            console.error(`[temet] no .jsonl session files found in ${resolvedPath}`);
+        }
+        process.exit(1);
+    }
+    if (!opts.json && !opts.quiet) {
+        printBanner();
+    }
+    if (!opts.quiet) {
+        console.error(`[temet] scanning ${sessionFiles.length} session file(s)...`);
+    }
+    let completedFiles = 0;
+    if (!opts.quiet) {
+        writeStepProgress(2, 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(2, totalSteps, "Scanning sessions", completedFiles, sessionFiles.length, event.file ? basename(event.file) : undefined);
+            return;
+        }
+        if (!scanDoneWritten) {
+            scanDoneWritten = true;
+            writeStepDone(2, totalSteps, "Scanning sessions", `${sessionFiles.length} files`);
+        }
+        if (event.phase === "signals") {
+            writeStepDone(3, totalSteps, "Extracting signals", `${formatCount(event.current ?? 0)} signals`, event.elapsedMs);
+            return;
+        }
+        if (event.phase === "patterns") {
+            writeStepDone(4, 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(5, 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(resolvedPath, 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.openReport && !opts.json) {
+        const reportModule = await import("./lib/report-writer.js");
+        const content = reportModule.buildAuditTextReport(result, competencies, bilan, tracking);
+        const projectLabel = tracking?.current.projectLabel ?? basename(resolvedPath);
+        const filePath = await reportModule.saveAuditTextReport(projectLabel, content);
+        await reportModule.openReportFile(filePath);
+        console.error(`${dim(`[temet] opened report: ${filePath}`, process.stderr)}`);
+    }
+    if (!opts.json) {
+        console.error(`${ok("done", process.stderr)} ${dim(`in ${formatMs(Date.now() - commandStartedAt)}`, process.stderr)}`);
+    }
+}