@temet/cli 0.2.0 → 0.3.1

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 {};

package/dist/lib/hook-installer.js

@@ -0,0 +1,130 @@
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+const SETTINGS_PATH = path.join(homedir(), ".claude", "settings.json");
+const HOOK_MARKER = "audit --track --quiet --notify";
+function shellQuote(s) {
+    if (/^[a-zA-Z0-9_/.:-]+$/.test(s))
+        return s;
+    return `'${s.replace(/'/g, "'\\''")}'`;
+}
+/** Resolve the absolute path for the temet binary at install time. */
+export function resolveTemetBinary() {
+    // 1. The current entry point (most reliable — we're running it right now)
+    const selfEntry = process.argv[1];
+    if (selfEntry && existsSync(selfEntry)) {
+        return `${shellQuote(process.execPath)} ${shellQuote(selfEntry)}`;
+    }
+    // 2. which temet
+    try {
+        const result = execSync("which temet 2>/dev/null", {
+            encoding: "utf8",
+        }).trim();
+        if (result)
+            return shellQuote(result);
+    }
+    catch {
+        /* not found */
+    }
+    // 3. global npm install path
+    try {
+        const globalRoot = execSync("npm root -g 2>/dev/null", {
+            encoding: "utf8",
+        }).trim();
+        const candidate = path.join(globalRoot, "@temet/cli/dist/index.js");
+        if (existsSync(candidate)) {
+            return `${shellQuote(process.execPath)} ${shellQuote(candidate)}`;
+        }
+    }
+    catch {
+        /* not found */
+    }
+    return null;
+}
+export function readSettings(settingsPath) {
+    let raw;
+    try {
+        raw = readFileSync(settingsPath, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return {};
+        throw new Error(`Cannot read ${settingsPath}: ${err.message}`);
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed === "object" &&
+            parsed !== null &&
+            !Array.isArray(parsed)) {
+            return parsed;
+        }
+        throw new Error(`${settingsPath} is not a JSON object`);
+    }
+    catch (err) {
+        if (err instanceof SyntaxError) {
+            throw new Error(`${settingsPath} contains invalid JSON — refusing to overwrite`);
+        }
+        throw err;
+    }
+}
+export function writeSettings(settingsPath, settings) {
+    mkdirSync(path.dirname(settingsPath), { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(settings, null, "\t") + "\n", "utf8");
+}
+function getSessionEndHooks(settings) {
+    const hooks = settings.hooks;
+    if (!hooks)
+        return null;
+    const sessionEnd = hooks.SessionEnd;
+    return Array.isArray(sessionEnd) ? sessionEnd : null;
+}
+/** Check if a temet SessionEnd hook is already installed. */
+export function isHookInstalled(settings) {
+    const matchers = getSessionEndHooks(settings);
+    if (!matchers)
+        return false;
+    return matchers.some((m) => m.hooks?.some((h) => h.command?.includes(HOOK_MARKER)));
+}
+/** Add the SessionEnd hook entry. Idempotent. */
+export function installHook(settings, binaryCommand) {
+    const command = `${binaryCommand} audit --track --quiet --notify >/dev/null 2>&1`;
+    const hookEntry = { type: "command", command, timeout: 60 };
+    const matcher = { matcher: "*", hooks: [hookEntry] };
+    if (!settings.hooks) {
+        settings.hooks = {};
+    }
+    const hooks = settings.hooks;
+    const existing = hooks.SessionEnd;
+    if (!Array.isArray(existing)) {
+        hooks.SessionEnd = [matcher];
+        return settings;
+    }
+    // Check if already present
+    const alreadyPresent = existing.some((m) => m.hooks?.some((h) => h.command?.includes(HOOK_MARKER)));
+    if (alreadyPresent)
+        return settings;
+    existing.push(matcher);
+    return settings;
+}
+/** Remove the temet SessionEnd hook entry. */
+export function uninstallHook(settings) {
+    const hooks = settings.hooks;
+    if (!hooks)
+        return settings;
+    const existing = hooks.SessionEnd;
+    if (!Array.isArray(existing))
+        return settings;
+    hooks.SessionEnd = existing.filter((m) => !m.hooks?.some((h) => h.command?.includes(HOOK_MARKER)));
+    // Cleanup empty arrays and objects
+    if (hooks.SessionEnd.length === 0) {
+        delete hooks.SessionEnd;
+    }
+    if (Object.keys(hooks).length === 0) {
+        delete settings.hooks;
+    }
+    return settings;
+}
+export function getSettingsPath() {
+    return SETTINGS_PATH;
+}

package/dist/lib/narrator-lite.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Lightweight narrator — raw fetch to Anthropic Messages API.
+ * No AI SDK dependency.
+ *
+ * Auth priority:
+ *   1. CLAUDE_AUTH_TOKEN + CLAUDE_API_BASE_URL  (Claude bearer proxy — primary)
+ *   2. ANTHROPIC_API_KEY + api.anthropic.com     (direct Anthropic — explicit fallback)
+ */
+import type { CompetencyEntry } from "./types.js";
+import type { CombinedStats } from "./analysis-types.js";
+import type { DetectedWorkflow } from "./workflow-detector.js";
+export type NarrationResult = {
+    competencies: CompetencyEntry[];
+    bilan: string;
+};
+type AuthConfig = {
+    url: string;
+    headers: Record<string, string>;
+    source: string;
+};
+export declare function resolveAuth(): AuthConfig | null;
+export declare function narrateCompetencies(raw: CompetencyEntry[], combined: CombinedStats, workflows: DetectedWorkflow[], options?: {
+    model?: string;
+}): Promise<NarrationResult>;
+export {};