@temet/cli 0.2.0 → 0.3.0

package/dist/lib/audit-tracking.d.ts

@@ -0,0 +1,55 @@
+import type { AuditResult } from "./session-audit.js";
+import type { CompetencyEntry, ProficiencyLevel } from "./types.js";
+export type AuditSkillSnapshot = {
+    name: string;
+    category: string;
+    proficiencyLevel: ProficiencyLevel;
+    evidenceCount: number;
+};
+export type AuditWorkflowSnapshot = {
+    description: string;
+    sequence: string[];
+    occurrences: number;
+    sessions: number;
+    confidence: number;
+};
+export type AuditSnapshot = {
+    version: 1;
+    createdAt: string;
+    projectKey: string;
+    projectLabel: string;
+    sourcePath: string;
+    sessions: number;
+    messages: number;
+    toolCalls: number;
+    skills: AuditSkillSnapshot[];
+    workflows: AuditWorkflowSnapshot[];
+};
+export type AuditChange = {
+    type: "baseline";
+    title: string;
+    detail: string;
+} | {
+    type: "new_skill" | "level_up" | "level_down" | "new_workflow";
+    title: string;
+    detail: string;
+};
+export type TrackingResult = {
+    previous: AuditSnapshot | null;
+    current: AuditSnapshot;
+    changes: AuditChange[];
+    latestPath: string;
+    historyPath: string;
+    skipped: boolean;
+};
+export declare function buildProjectKey(sourcePath: string): string;
+export declare function buildAuditSnapshot(sourcePath: string, result: Pick<AuditResult, "sessionCount" | "messageCount" | "toolCallCount" | "workflows">, competencies: CompetencyEntry[]): AuditSnapshot;
+export declare function loadLatestSnapshot(sourcePath: string): Promise<AuditSnapshot | null>;
+export declare function saveAuditSnapshot(snapshot: AuditSnapshot): Promise<{
+    latestPath: string;
+    historyPath: string;
+}>;
+export declare function diffAuditSnapshots(previous: AuditSnapshot | null, current: AuditSnapshot): AuditChange[];
+/** Check if two snapshots have identical skills and workflows (ignoring timestamps/counts). */
+export declare function snapshotsEqual(a: AuditSnapshot, b: AuditSnapshot): boolean;
+export declare function trackAuditSnapshot(sourcePath: string, result: Pick<AuditResult, "sessionCount" | "messageCount" | "toolCallCount" | "workflows">, competencies: CompetencyEntry[]): Promise<TrackingResult>;

package/dist/lib/audit-tracking.js

@@ -0,0 +1,185 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+const PROFICIENCY_ORDER = {
+    novice: 0,
+    advanced_beginner: 1,
+    competent: 2,
+    proficient: 3,
+    expert: 4,
+};
+function normalizeName(value) {
+    return value.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function evidenceCount(entry) {
+    return (entry.evidence.examples.length +
+        entry.evidence.decisionCriteria.length +
+        entry.evidence.antiPatterns.length +
+        entry.evidence.mentorAdvice.length);
+}
+export function buildProjectKey(sourcePath) {
+    return createHash("sha256")
+        .update(path.resolve(sourcePath))
+        .digest("hex")
+        .slice(0, 12);
+}
+function buildProjectLabel(sourcePath) {
+    const resolved = path.resolve(sourcePath);
+    const base = path.basename(resolved);
+    return base || resolved;
+}
+export function buildAuditSnapshot(sourcePath, result, competencies) {
+    return {
+        version: 1,
+        createdAt: new Date().toISOString(),
+        projectKey: buildProjectKey(sourcePath),
+        projectLabel: buildProjectLabel(sourcePath),
+        sourcePath: path.resolve(sourcePath),
+        sessions: result.sessionCount,
+        messages: result.messageCount,
+        toolCalls: result.toolCallCount,
+        skills: competencies
+            .map((entry) => ({
+            name: entry.name,
+            category: entry.category,
+            proficiencyLevel: entry.proficiencyLevel,
+            evidenceCount: evidenceCount(entry),
+        }))
+            .sort((a, b) => a.name.localeCompare(b.name)),
+        workflows: result.workflows
+            .map((workflow) => ({
+            description: workflow.description,
+            sequence: workflow.sequence,
+            occurrences: workflow.occurrences,
+            sessions: workflow.sessions,
+            confidence: workflow.confidence,
+        }))
+            .sort((a, b) => a.description.localeCompare(b.description)),
+    };
+}
+function getTrackingPaths(projectKey) {
+    const root = path.join(homedir(), ".temet", "audits", projectKey);
+    return {
+        root,
+        latest: path.join(root, "latest.json"),
+        historyDir: path.join(root, "history"),
+    };
+}
+export async function loadLatestSnapshot(sourcePath) {
+    const { latest } = getTrackingPaths(buildProjectKey(sourcePath));
+    try {
+        const raw = await readFile(latest, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed?.version !== 1)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveAuditSnapshot(snapshot) {
+    const paths = getTrackingPaths(snapshot.projectKey);
+    await mkdir(paths.historyDir, { recursive: true });
+    const historyPath = path.join(paths.historyDir, `${snapshot.createdAt.replaceAll(":", "-")}.json`);
+    const payload = JSON.stringify(snapshot, null, 2);
+    await writeFile(paths.latest, payload, "utf8");
+    await writeFile(historyPath, payload, "utf8");
+    return { latestPath: paths.latest, historyPath };
+}
+export function diffAuditSnapshots(previous, current) {
+    if (!previous) {
+        return [
+            {
+                type: "baseline",
+                title: "Tracking baseline created",
+                detail: `Saved the first audit snapshot for ${current.projectLabel}.`,
+            },
+        ];
+    }
+    const changes = [];
+    const previousSkills = new Map(previous.skills.map((skill) => [normalizeName(skill.name), skill]));
+    const currentSkills = new Map(current.skills.map((skill) => [normalizeName(skill.name), skill]));
+    for (const [key, skill] of currentSkills) {
+        const before = previousSkills.get(key);
+        if (!before) {
+            if (PROFICIENCY_ORDER[skill.proficiencyLevel] >=
+                PROFICIENCY_ORDER.competent ||
+                skill.evidenceCount >= 2) {
+                changes.push({
+                    type: "new_skill",
+                    title: `New skill surfaced: ${skill.name}`,
+                    detail: `${skill.proficiencyLevel.replace("_", " ")} with ${skill.evidenceCount} evidence item(s).`,
+                });
+            }
+            continue;
+        }
+        const beforeLevel = PROFICIENCY_ORDER[before.proficiencyLevel];
+        const currentLevel = PROFICIENCY_ORDER[skill.proficiencyLevel];
+        if (currentLevel > beforeLevel) {
+            changes.push({
+                type: "level_up",
+                title: `${skill.name} moved up`,
+                detail: `${before.proficiencyLevel.replace("_", " ")} → ${skill.proficiencyLevel.replace("_", " ")}`,
+            });
+        }
+        else if (currentLevel < beforeLevel) {
+            changes.push({
+                type: "level_down",
+                title: `${skill.name} moved down`,
+                detail: `${before.proficiencyLevel.replace("_", " ")} → ${skill.proficiencyLevel.replace("_", " ")}`,
+            });
+        }
+    }
+    const previousWorkflows = new Set(previous.workflows.map((workflow) => normalizeName(workflow.description)));
+    for (const workflow of current.workflows) {
+        const key = normalizeName(workflow.description);
+        if (!previousWorkflows.has(key)) {
+            changes.push({
+                type: "new_workflow",
+                title: `New repeated pattern: ${workflow.description}`,
+                detail: `${workflow.occurrences} occurrences across ${workflow.sessions} sessions.`,
+            });
+        }
+    }
+    const order = {
+        baseline: 0,
+        level_up: 1,
+        new_skill: 2,
+        new_workflow: 3,
+        level_down: 4,
+    };
+    return changes.sort((a, b) => order[a.type] - order[b.type]).slice(0, 8);
+}
+/** Check if two snapshots have identical skills and workflows (ignoring timestamps/counts). */
+export function snapshotsEqual(a, b) {
+    return (JSON.stringify(a.skills) === JSON.stringify(b.skills) &&
+        JSON.stringify(a.workflows) === JSON.stringify(b.workflows));
+}
+export async function trackAuditSnapshot(sourcePath, result, competencies) {
+    const previous = await loadLatestSnapshot(sourcePath);
+    const current = buildAuditSnapshot(sourcePath, result, competencies);
+    // No-op guard: skip save if skills and workflows are identical
+    if (previous && snapshotsEqual(previous, current)) {
+        const paths = getTrackingPaths(current.projectKey);
+        return {
+            previous,
+            current,
+            changes: [],
+            latestPath: paths.latest,
+            historyPath: "",
+            skipped: true,
+        };
+    }
+    const changes = diffAuditSnapshots(previous, current);
+    const { latestPath, historyPath } = await saveAuditSnapshot(current);
+    return {
+        previous,
+        current,
+        changes,
+        latestPath,
+        historyPath,
+        skipped: false,
+    };
+}

package/dist/lib/cli-args.d.ts

@@ -0,0 +1,21 @@
+export type FlagValue = string | boolean;
+export type AuditCliOptions = {
+    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 parseFlagBag(args: string[]): {
+    flags: Map<string, FlagValue>;
+    positionals: string[];
+};
+export declare function readOptionalString(flags: Map<string, FlagValue>, key: string): string | null;
+export declare function buildAuditCliOptions(flags: Map<string, FlagValue>, env: NodeJS.ProcessEnv): AuditCliOptions;

package/dist/lib/cli-args.js

@@ -0,0 +1,60 @@
+export function parseFlagBag(args) {
+    const flags = new Map();
+    const positionals = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "-y") {
+            flags.set("yes", true);
+            continue;
+        }
+        if (!arg.startsWith("--")) {
+            positionals.push(arg);
+            continue;
+        }
+        if (arg === "--dry-run" ||
+            arg === "--track" ||
+            arg === "--narrate" ||
+            arg === "--json" ||
+            arg === "--quiet" ||
+            arg === "--notify" ||
+            arg === "--publish" ||
+            arg === "--yes") {
+            flags.set(arg.slice(2), 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 };
+}
+export 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;
+}
+export function buildAuditCliOptions(flags, env) {
+    const pathVal = readOptionalString(flags, "path") ?? "";
+    return {
+        path: pathVal,
+        track: Boolean(flags.get("track")),
+        narrate: Boolean(flags.get("narrate")),
+        json: Boolean(flags.get("json")),
+        quiet: Boolean(flags.get("quiet")),
+        notify: Boolean(flags.get("notify")),
+        publish: Boolean(flags.get("publish")),
+        yes: Boolean(flags.get("yes")),
+        model: readOptionalString(flags, "model") ?? "",
+        address: readOptionalString(flags, "address") ?? env.TEMET_ADDRESS ?? "",
+        token: readOptionalString(flags, "token") ?? env.TEMET_TOKEN ?? "",
+        relayUrl: readOptionalString(flags, "relay-url") ??
+            env.RELAY_URL ??
+            "https://temet-relay.ramponneau.workers.dev",
+    };
+}

package/dist/lib/heuristics.d.ts

@@ -0,0 +1,15 @@
+import type { SessionStats } from "./session-parser.js";
+export type Signal = {
+    type: string;
+    skill: string;
+    confidence: number;
+    evidence: string;
+    category?: string;
+};
+export declare function extractCorrectionPatterns(stats: SessionStats): Signal[];
+export declare function extractToolFrequency(stats: SessionStats): Signal[];
+export declare function extractDecisionLanguage(stats: SessionStats): Signal[];
+export declare function extractDomainClusters(stats: SessionStats): Signal[];
+export declare function extractPromptStructure(stats: SessionStats): Signal[];
+export declare const ALL_EXTRACTORS: readonly [typeof extractCorrectionPatterns, typeof extractToolFrequency, typeof extractDecisionLanguage, typeof extractDomainClusters, typeof extractPromptStructure];
+export declare function extractAllSignals(stats: SessionStats): Signal[];

package/dist/lib/heuristics.js

@@ -0,0 +1,341 @@
+// ---------- 1. Correction Patterns ----------
+const CORRECTION_PATTERNS = [
+    // French
+    /\bnon\b/i,
+    /\bpas comme [cç]a\b/i,
+    /\bc'est pas\b/i,
+    /\bplut[oô]t\b/i,
+    /\brevert\b/i,
+    /\bannule\b/i,
+    /\brefais\b/i,
+    /\bmauvais\b/i,
+    /\bincorrect\b/i,
+    // English
+    /\bwrong\b/i,
+    /\bnot like that\b/i,
+    /\bno[,.]?\s/i,
+    /\bundo\b/i,
+    /\bdon't\b/i,
+    /\bshouldn't\b/i,
+    /\bactually\b/i,
+    /\binstead\b/i,
+];
+export function extractCorrectionPatterns(stats) {
+    const signals = [];
+    const { messages } = stats;
+    for (let i = 1; i < messages.length; i++) {
+        const msg = messages[i];
+        if (msg.role !== "user")
+            continue;
+        // Check if previous message was from assistant
+        const prev = messages[i - 1];
+        if (!prev || prev.role !== "assistant")
+            continue;
+        const userText = getTextContent(msg);
+        if (!userText)
+            continue;
+        for (const pattern of CORRECTION_PATTERNS) {
+            if (pattern.test(userText)) {
+                // Extract what the assistant was doing from the previous message
+                const assistantContext = getTextContent(prev);
+                const toolNames = getToolNames(prev);
+                const context = toolNames.length > 0
+                    ? `tools: ${toolNames.join(", ")}`
+                    : truncate(assistantContext, 100);
+                signals.push({
+                    type: "correction",
+                    skill: inferSkillFromCorrection(userText, context),
+                    confidence: 0.6,
+                    evidence: `User correction: "${truncate(userText, 120)}" (after ${context})`,
+                    category: "judgment",
+                });
+                break; // One signal per message
+            }
+        }
+    }
+    return signals;
+}
+function inferSkillFromCorrection(userText, context) {
+    const text = `${userText} ${context}`.toLowerCase();
+    if (/git|commit|branch|push|merge/.test(text))
+        return "version control judgment";
+    if (/test|spec|assert/.test(text))
+        return "testing methodology";
+    if (/css|style|layout|design/.test(text))
+        return "UI/UX design sense";
+    if (/type|interface|schema/.test(text))
+        return "type system design";
+    if (/security|auth|token/.test(text))
+        return "security awareness";
+    if (/perf|optim|speed|slow/.test(text))
+        return "performance optimization";
+    if (/api|route|endpoint/.test(text))
+        return "API design";
+    if (/archi|struct|pattern/.test(text))
+        return "software architecture";
+    return "code review judgment";
+}
+// ---------- 2. Tool Frequency ----------
+const TOOL_CLUSTERS = {
+    Grep: { skill: "code archaeology", category: "tool_proficiency" },
+    Glob: { skill: "codebase navigation", category: "tool_proficiency" },
+    Read: { skill: "code comprehension", category: "hard_skill" },
+    Edit: { skill: "code editing precision", category: "hard_skill" },
+    Write: { skill: "code generation", category: "hard_skill" },
+    Bash: { skill: "shell scripting", category: "tool_proficiency" },
+    Agent: { skill: "task delegation", category: "methodology" },
+    WebSearch: { skill: "research methodology", category: "methodology" },
+    WebFetch: { skill: "API integration", category: "hard_skill" },
+};
+export function extractToolFrequency(stats) {
+    const signals = [];
+    const counts = new Map();
+    for (const tc of stats.toolCalls) {
+        counts.set(tc.name, (counts.get(tc.name) ?? 0) + 1);
+    }
+    const total = stats.toolCalls.length;
+    if (total === 0)
+        return signals;
+    // Also detect git usage in Bash commands
+    let gitCount = 0;
+    for (const tc of stats.toolCalls) {
+        if (tc.name === "Bash") {
+            const cmd = tc.input?.command;
+            if (typeof cmd === "string" && /\bgit\b/.test(cmd)) {
+                gitCount++;
+            }
+        }
+    }
+    if (gitCount > 3) {
+        const freq = gitCount / total;
+        signals.push({
+            type: "tool_frequency",
+            skill: "version control mastery",
+            confidence: Math.min(0.5 + freq * 2, 0.95),
+            evidence: `${gitCount} git commands out of ${total} total tool calls (${(freq * 100).toFixed(1)}%)`,
+            category: "tool_proficiency",
+        });
+    }
+    for (const [tool, info] of Object.entries(TOOL_CLUSTERS)) {
+        const count = counts.get(tool) ?? 0;
+        if (count < 3)
+            continue;
+        const freq = count / total;
+        signals.push({
+            type: "tool_frequency",
+            skill: info.skill,
+            confidence: Math.min(0.4 + freq * 2, 0.9),
+            evidence: `${tool} used ${count}/${total} times (${(freq * 100).toFixed(1)}%)`,
+            category: info.category,
+        });
+    }
+    return signals;
+}
+// ---------- 3. Decision Language ----------
+const DECISION_PATTERNS = [
+    // French
+    { pattern: /je pr[eé]f[eè]re\s+(.{10,80})/i, mapTo: "preference" },
+    { pattern: /on va plut[oô]t\s+(.{10,80})/i, mapTo: "preference" },
+    { pattern: /toujours\s+(.{10,80})/i, mapTo: "always" },
+    { pattern: /jamais\s+(.{10,80})/i, mapTo: "never" },
+    { pattern: /il faut\s+(.{10,80})/i, mapTo: "always" },
+    { pattern: /on ne fait pas\s+(.{10,80})/i, mapTo: "never" },
+    // English
+    { pattern: /I prefer\s+(.{10,80})/i, mapTo: "preference" },
+    { pattern: /always\s+(.{10,80})/i, mapTo: "always" },
+    { pattern: /never\s+(.{10,80})/i, mapTo: "never" },
+    { pattern: /we should\s+(.{10,80})/i, mapTo: "preference" },
+    { pattern: /don'?t ever\s+(.{10,80})/i, mapTo: "never" },
+    { pattern: /make sure to\s+(.{10,80})/i, mapTo: "always" },
+];
+export function extractDecisionLanguage(stats) {
+    const signals = [];
+    for (const msg of stats.messages) {
+        if (msg.role !== "user")
+            continue;
+        const text = getTextContent(msg);
+        if (!text)
+            continue;
+        for (const { pattern, mapTo } of DECISION_PATTERNS) {
+            const match = pattern.exec(text);
+            if (!match)
+                continue;
+            const criterion = match[1].trim().replace(/[.!,;]+$/, "");
+            const skill = inferSkillFromDecision(criterion);
+            signals.push({
+                type: "decision_language",
+                skill,
+                confidence: mapTo === "always" || mapTo === "never" ? 0.7 : 0.5,
+                evidence: `${mapTo === "never" ? "Anti-pattern" : "Decision criterion"}: "${truncate(match[0], 100)}"`,
+                category: "judgment",
+            });
+        }
+    }
+    return signals;
+}
+function inferSkillFromDecision(text) {
+    const lower = text.toLowerCase();
+    if (/tab|indent|format|lint|biome/.test(lower))
+        return "code style standards";
+    if (/test|coverage|spec/.test(lower))
+        return "testing methodology";
+    if (/secur|auth|token|secret|\.env|credential/.test(lower))
+        return "security practices";
+    if (/commit|branch|pr|merge/.test(lower))
+        return "version control workflow";
+    if (/type|interface|generic/.test(lower))
+        return "type system design";
+    if (/error|catch|throw|handle/.test(lower))
+        return "error handling strategy";
+    if (/component|render|ui/.test(lower))
+        return "component architecture";
+    if (/api|route|endpoint|rest/.test(lower))
+        return "API design";
+    if (/perf|cache|optim/.test(lower))
+        return "performance optimization";
+    return "engineering judgment";
+}
+// ---------- 4. Domain Clustering ----------
+const DOMAIN_MAP = {
+    "lib/a2a": { skill: "agent-to-agent protocol", category: "domain_knowledge" },
+    "lib/ai": { skill: "AI/LLM integration", category: "domain_knowledge" },
+    "lib/competency": {
+        skill: "competency modeling",
+        category: "domain_knowledge",
+    },
+    "lib/db": { skill: "database design", category: "hard_skill" },
+    "lib/generative-ui": {
+        skill: "generative UI systems",
+        category: "hard_skill",
+    },
+    "components/": {
+        skill: "React component development",
+        category: "hard_skill",
+    },
+    "relay-worker": {
+        skill: "Cloudflare Workers development",
+        category: "hard_skill",
+    },
+    "app/api": { skill: "Next.js API routes", category: "hard_skill" },
+    "app/(chat)": {
+        skill: "chat application architecture",
+        category: "domain_knowledge",
+    },
+    scripts: {
+        skill: "build tooling and automation",
+        category: "tool_proficiency",
+    },
+    ".github": { skill: "CI/CD pipeline design", category: "methodology" },
+    content: { skill: "content strategy", category: "domain_knowledge" },
+};
+export function extractDomainClusters(stats) {
+    const signals = [];
+    const domainCounts = new Map();
+    for (const fp of stats.filesTouched) {
+        for (const [prefix, _info] of Object.entries(DOMAIN_MAP)) {
+            if (fp.includes(prefix)) {
+                domainCounts.set(prefix, (domainCounts.get(prefix) ?? 0) + 1);
+                break;
+            }
+        }
+    }
+    const totalFiles = stats.filesTouched.length;
+    if (totalFiles === 0)
+        return signals;
+    for (const [prefix, count] of domainCounts) {
+        if (count < 2)
+            continue;
+        const info = DOMAIN_MAP[prefix];
+        const freq = count / totalFiles;
+        signals.push({
+            type: "domain_cluster",
+            skill: info.skill,
+            confidence: Math.min(0.4 + freq * 1.5, 0.85),
+            evidence: `${count} files touched in ${prefix} (${(freq * 100).toFixed(1)}% of ${totalFiles} files)`,
+            category: info.category,
+        });
+    }
+    return signals;
+}
+// ---------- 5. Prompt Structure ----------
+export function extractPromptStructure(stats) {
+    const signals = [];
+    let longStructuredCount = 0;
+    let shortImperativeCount = 0;
+    let totalUserMessages = 0;
+    for (const msg of stats.messages) {
+        if (msg.role !== "user")
+            continue;
+        const text = getTextContent(msg);
+        if (!text)
+            continue;
+        // Skip tool results (user messages that are just tool output)
+        if (msg.content.some((b) => b.type === "tool_result"))
+            continue;
+        totalUserMessages++;
+        const len = text.length;
+        // Long numbered prompts = spec methodology
+        if (len > 500 && /(?:\d+[.)]\s|\n[-*]\s)/.test(text)) {
+            longStructuredCount++;
+        }
+        // Short imperatives = rapid iteration
+        else if (len < 100) {
+            shortImperativeCount++;
+        }
+    }
+    if (totalUserMessages === 0)
+        return signals;
+    if (longStructuredCount >= 2) {
+        const freq = longStructuredCount / totalUserMessages;
+        signals.push({
+            type: "prompt_structure",
+            skill: "specification methodology",
+            confidence: Math.min(0.5 + freq * 2, 0.9),
+            evidence: `${longStructuredCount}/${totalUserMessages} user messages are long structured specs (>500 chars with numbered lists)`,
+            category: "methodology",
+        });
+    }
+    if (shortImperativeCount >= 5) {
+        const freq = shortImperativeCount / totalUserMessages;
+        signals.push({
+            type: "prompt_structure",
+            skill: "rapid iteration workflow",
+            confidence: Math.min(0.4 + freq, 0.85),
+            evidence: `${shortImperativeCount}/${totalUserMessages} user messages are short imperatives (<100 chars)`,
+            category: "methodology",
+        });
+    }
+    return signals;
+}
+// ---------- All extractors ----------
+export const ALL_EXTRACTORS = [
+    extractCorrectionPatterns,
+    extractToolFrequency,
+    extractDecisionLanguage,
+    extractDomainClusters,
+    extractPromptStructure,
+];
+export function extractAllSignals(stats) {
+    const signals = [];
+    for (const extractor of ALL_EXTRACTORS) {
+        signals.push(...extractor(stats));
+    }
+    return signals;
+}
+// ---------- Util ----------
+function getTextContent(msg) {
+    return msg.content
+        .filter((b) => b.type === "text")
+        .map((b) => b.text)
+        .join("\n");
+}
+function getToolNames(msg) {
+    return msg.content
+        .filter((b) => b.type === "tool_use")
+        .map((b) => b.name);
+}
+function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    return `${s.slice(0, max)}...`;
+}

package/dist/lib/hook-installer.d.ts

@@ -0,0 +1,13 @@
+type JsonObject = Record<string, unknown>;
+/** Resolve the absolute path for the temet binary at install time. */
+export declare function resolveTemetBinary(): string | null;
+export declare function readSettings(settingsPath: string): JsonObject;
+export declare function writeSettings(settingsPath: string, settings: JsonObject): void;
+/** Check if a temet SessionEnd hook is already installed. */
+export declare function isHookInstalled(settings: JsonObject): boolean;
+/** Add the SessionEnd hook entry. Idempotent. */
+export declare function installHook(settings: JsonObject, binaryCommand: string): JsonObject;
+/** Remove the temet SessionEnd hook entry. */
+export declare function uninstallHook(settings: JsonObject): JsonObject;
+export declare function getSettingsPath(): string;
+export {};