@temet/cli 0.2.0 → 0.3.0

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

package/dist/lib/narrator-lite.js

@@ -0,0 +1,231 @@
+// ---------- Excerpt Selection ----------
+const CORRECTION_RX = [
+    /\bnon\b/i,
+    /\bpas comme [cç]a\b/i,
+    /\bc'est pas\b/i,
+    /\bplut[oô]t\b/i,
+    /\brevert\b/i,
+    /\bwrong\b/i,
+    /\bnot like that\b/i,
+    /\bundo\b/i,
+    /\bactually\b/i,
+    /\binstead\b/i,
+];
+const DECISION_RX = [
+    /je pr[eé]f[eè]re/i,
+    /toujours\s/i,
+    /jamais\s/i,
+    /il faut/i,
+    /I prefer/i,
+    /always\s/i,
+    /never\s/i,
+    /we should/i,
+    /make sure to/i,
+];
+function getTextContent(msg) {
+    return msg.content
+        .filter((b) => b.type === "text")
+        .map((b) => b.text)
+        .join("\n");
+}
+function scoreMessage(msg) {
+    const text = getTextContent(msg);
+    if (!text)
+        return 0;
+    let score = 0;
+    for (const rx of CORRECTION_RX) {
+        if (rx.test(text)) {
+            score += 3;
+            break;
+        }
+    }
+    for (const rx of DECISION_RX) {
+        if (rx.test(text)) {
+            score += 2;
+            break;
+        }
+    }
+    if (text.length > 500)
+        score += 1;
+    return score;
+}
+function selectExcerpts(combined, max = 10) {
+    return combined.messages
+        .filter((m) => m.role === "user")
+        .map((m) => ({ msg: m, score: scoreMessage(m) }))
+        .filter((s) => s.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, max)
+        .map((s) => ({
+        text: getTextContent(s.msg).slice(0, 300),
+        role: s.msg.role,
+    }));
+}
+// ---------- Prompt ----------
+function buildPrompt(raw, excerpts, workflows) {
+    const competencyList = raw
+        .map((c) => `- ${c.name} [${c.proficiencyLevel}] (${c.category}): ${c.description}`)
+        .join("\n");
+    const excerptList = excerpts
+        .map((e, i) => `${i + 1}. "${e.text}"`)
+        .join("\n");
+    const workflowList = workflows.length > 0
+        ? workflows
+            .map((w) => `- ${w.description}: ${w.sequence.join(" → ")} (${w.occurrences}x across ${w.sessions} sessions)`)
+            .join("\n")
+        : "None detected.";
+    return `You are analyzing a developer's coding sessions to produce a professional competency profile.
+
+## Raw Competencies (from heuristic analysis)
+${competencyList}
+
+## User Excerpts (from sessions)
+${excerptList}
+
+## Detected Workflows
+${workflowList}
+
+## Instructions
+
+Return a JSON object with exactly two keys:
+
+1. "competencies": an array of enriched competency objects. For each raw competency above, produce an object with these fields:
+   - "id": same as raw
+   - "name": same as raw
+   - "category": same as raw
+   - "proficiencyLevel": same as raw (adjust only if evidence strongly supports a different level)
+   - "description": a 1-2 sentence narrative description (not the raw heuristic output)
+   - "evidence": object with:
+     - "examples": array of 2-4 concrete examples drawn from the excerpts/workflows
+     - "decisionCriteria": array of 1-3 decision principles the developer follows
+     - "antiPatterns": array of 1-2 things the developer avoids
+     - "mentorAdvice": array of 1-2 insights about how this developer works
+   - "prerequisites": array of related skills needed (0-3)
+   - "synergies": array of complementary skills (0-3)
+
+2. "bilan": a markdown narrative summary (300-600 words) covering:
+   - Developer profile overview
+   - Key strengths and surprising patterns
+   - Workflow patterns and methodology
+   - Progression areas and recommendations
+
+Keep descriptions professional but human. Ground everything in the evidence provided.
+Return ONLY valid JSON, no markdown fences.`;
+}
+// ---------- Response Parser ----------
+function ensureStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((v) => typeof v === "string");
+}
+function parseResponse(text, fallback) {
+    try {
+        const cleaned = text
+            .replace(/^```json?\s*/m, "")
+            .replace(/```\s*$/m, "")
+            .trim();
+        const parsed = JSON.parse(cleaned);
+        if (!parsed.competencies ||
+            !Array.isArray(parsed.competencies) ||
+            !parsed.bilan ||
+            typeof parsed.bilan !== "string") {
+            return { competencies: fallback, bilan: "" };
+        }
+        const validated = [];
+        for (const c of parsed.competencies) {
+            if (!c ||
+                typeof c !== "object" ||
+                !c.id ||
+                !c.name ||
+                !c.category ||
+                !c.proficiencyLevel)
+                continue;
+            const ev = c.evidence && typeof c.evidence === "object" ? c.evidence : {};
+            validated.push({
+                ...c,
+                description: typeof c.description === "string" ? c.description : "",
+                evidence: {
+                    examples: ensureStringArray(ev.examples),
+                    decisionCriteria: ensureStringArray(ev.decisionCriteria),
+                    antiPatterns: ensureStringArray(ev.antiPatterns),
+                    mentorAdvice: ensureStringArray(ev.mentorAdvice),
+                },
+                prerequisites: ensureStringArray(c.prerequisites),
+                synergies: ensureStringArray(c.synergies),
+            });
+        }
+        if (validated.length === 0)
+            return { competencies: fallback, bilan: parsed.bilan ?? "" };
+        return { competencies: validated, bilan: parsed.bilan };
+    }
+    catch {
+        return { competencies: fallback, bilan: "" };
+    }
+}
+export function resolveAuth() {
+    const claudeToken = process.env.CLAUDE_AUTH_TOKEN;
+    const claudeBase = process.env.CLAUDE_API_BASE_URL;
+    // Primary: Claude bearer proxy (same path as the app's provider chain)
+    if (claudeToken) {
+        const base = claudeBase ?? "https://api.anthropic.com";
+        const url = base.includes("/v1/messages") ? base : `${base}/v1/messages`;
+        return {
+            url,
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${claudeToken}`,
+                "anthropic-version": "2023-06-01",
+            },
+            source: "CLAUDE_AUTH_TOKEN",
+        };
+    }
+    // Fallback: direct Anthropic API key
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (apiKey) {
+        return {
+            url: "https://api.anthropic.com/v1/messages",
+            headers: {
+                "Content-Type": "application/json",
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01",
+            },
+            source: "ANTHROPIC_API_KEY",
+        };
+    }
+    return null;
+}
+// ---------- API Call ----------
+export async function narrateCompetencies(raw, combined, workflows, options) {
+    const auth = resolveAuth();
+    if (!auth) {
+        console.error("[temet] --narrate requires model access. Set ANTHROPIC_API_KEY or CLAUDE_AUTH_TOKEN.");
+        return { competencies: raw, bilan: "" };
+    }
+    const model = options?.model ?? "claude-haiku-4-5-20251001";
+    const excerpts = selectExcerpts(combined);
+    const prompt = buildPrompt(raw, excerpts, workflows);
+    console.error(`[temet] narrator using ${auth.source}`);
+    try {
+        const resp = await fetch(auth.url, {
+            method: "POST",
+            headers: auth.headers,
+            body: JSON.stringify({
+                model,
+                max_tokens: 4096,
+                messages: [{ role: "user", content: prompt }],
+            }),
+        });
+        if (!resp.ok) {
+            const body = await resp.text();
+            console.error(`[temet] narrator API error (${resp.status}): ${body}`);
+            return { competencies: raw, bilan: "" };
+        }
+        const data = (await resp.json());
+        const text = data.content?.find((b) => b.type === "text")?.text ?? "";
+        return parseResponse(text, raw);
+    }
+    catch (err) {
+        console.error("[temet] narrator call failed:", err);
+        return { competencies: raw, bilan: "" };
+    }
+}

package/dist/lib/notifier.d.ts

@@ -0,0 +1,9 @@
+import type { AuditChange } from "./audit-tracking.js";
+export type NotificationPayload = {
+    title: string;
+    body: string;
+};
+/** Build the notification text from audit changes. Returns null if nothing to notify. */
+export declare function formatNotification(changes: AuditChange[], projectLabel: string): NotificationPayload | null;
+/** Send a native OS notification. Fire-and-forget. */
+export declare function sendNotification(payload: NotificationPayload): Promise<void>;

package/dist/lib/notifier.js

@@ -0,0 +1,57 @@
+import { execFile } from "node:child_process";
+import { appendFile, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+/** Build the notification text from audit changes. Returns null if nothing to notify. */
+export function formatNotification(changes, projectLabel) {
+    if (changes.length === 0)
+        return null;
+    // Baseline
+    if (changes.length === 1 && changes[0].type === "baseline") {
+        const skillCount = changes[0].detail.match(/(\d+)/)?.[1] ?? "0";
+        return {
+            title: "Temet",
+            body: `Tracking started for ${projectLabel}`,
+        };
+    }
+    const meaningful = changes.filter((c) => c.type !== "baseline");
+    if (meaningful.length === 0)
+        return null;
+    const first = meaningful[0];
+    const body = meaningful.length === 1
+        ? first.title
+        : `${first.title} and ${meaningful.length - 1} more`;
+    return { title: "Temet", body };
+}
+/** Send a native OS notification. Fire-and-forget. */
+export async function sendNotification(payload) {
+    const { title, body } = payload;
+    if (process.platform === "darwin") {
+        return new Promise((resolve, reject) => {
+            const escaped = body.replace(/"/g, '\\"');
+            const script = `display notification "${escaped}" with title "${title.replace(/"/g, '\\"')}"`;
+            execFile("osascript", ["-e", script], (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    if (process.platform === "linux") {
+        return new Promise((resolve, reject) => {
+            execFile("notify-send", [title, body], (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    // Fallback: log to file
+    const logDir = path.join(homedir(), ".temet");
+    await mkdir(logDir, { recursive: true });
+    const logPath = path.join(logDir, "notifications.log");
+    const line = `[${new Date().toISOString()}] ${title}: ${body}\n`;
+    await appendFile(logPath, line, "utf8");
+}

package/dist/lib/path-resolver.d.ts

@@ -0,0 +1,18 @@
+/** Convert an absolute project directory to the Claude Code session directory slug. */
+export declare function cwdToSessionDir(cwd: string): string;
+/**
+ * Try to read the JSON stdin from a Claude Code hook (non-blocking).
+ * Only safe to call when we know stdin has finite piped data (hook context).
+ * Consumes stdin — call at most once per process.
+ */
+export declare function readHookStdin(): {
+    cwd?: string;
+} | null;
+/**
+ * Resolve the session path by priority:
+ * 1. Explicit --path value
+ * 2. $CLAUDE_PROJECT_DIR env var
+ * 3. stdin JSON cwd (hook context)
+ * 4. process.cwd()
+ */
+export declare function resolveSessionPath(explicit: string | undefined, env: NodeJS.ProcessEnv): string | null;

package/dist/lib/path-resolver.js

@@ -0,0 +1,56 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+/** Convert an absolute project directory to the Claude Code session directory slug. */
+export function cwdToSessionDir(cwd) {
+    const slug = path.resolve(cwd).replace(/\//g, "-");
+    return path.join(homedir(), ".claude", "projects", slug);
+}
+/**
+ * Try to read the JSON stdin from a Claude Code hook (non-blocking).
+ * Only safe to call when we know stdin has finite piped data (hook context).
+ * Consumes stdin — call at most once per process.
+ */
+export function readHookStdin() {
+    try {
+        // Only attempt if stdin is piped (non-TTY) AND we're in a hook context.
+        // CLAUDECODE env var is set when running inside Claude Code.
+        if (process.stdin.isTTY)
+            return null;
+        if (!process.env.CLAUDECODE)
+            return null;
+        const data = readFileSync(0, "utf8");
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve the session path by priority:
+ * 1. Explicit --path value
+ * 2. $CLAUDE_PROJECT_DIR env var
+ * 3. stdin JSON cwd (hook context)
+ * 4. process.cwd()
+ */
+export function resolveSessionPath(explicit, env) {
+    if (explicit)
+        return explicit;
+    // Priority 2: CLAUDE_PROJECT_DIR env var (guaranteed in Claude Code hooks)
+    const projectDir = env.CLAUDE_PROJECT_DIR;
+    if (projectDir) {
+        const d = cwdToSessionDir(projectDir);
+        if (existsSync(d))
+            return d;
+    }
+    // Priority 3: stdin JSON cwd (hook context)
+    const hookInput = readHookStdin();
+    if (hookInput?.cwd) {
+        const d = cwdToSessionDir(hookInput.cwd);
+        if (existsSync(d))
+            return d;
+    }
+    // Priority 4: process.cwd()
+    const d = cwdToSessionDir(process.cwd());
+    return existsSync(d) ? d : null;
+}

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

@@ -0,0 +1,23 @@
+import type { CombinedStats } from "./analysis-types.js";
+import { type Signal } from "./heuristics.js";
+import { type DetectedWorkflow } from "./workflow-detector.js";
+import type { CompetencyEntry } from "./types.js";
+export type AuditResult = {
+    sessionCount: number;
+    messageCount: number;
+    toolCallCount: number;
+    signalCount: number;
+    workflowCount: number;
+    competencies: CompetencyEntry[];
+    workflows: DetectedWorkflow[];
+    signals: Signal[];
+    combined: CombinedStats;
+};
+export declare function findSessionFiles(dirPath: string): string[];
+export declare function runAudit(sessionFiles: string[], onProgress?: (event: {
+    phase: "scan" | "signals" | "patterns";
+    file?: string;
+    current?: number;
+    total?: number;
+    elapsedMs?: number;
+}) => void): Promise<AuditResult>;

package/dist/lib/session-audit.js

@@ -0,0 +1,92 @@
+// Adapted from scripts/lib/session-audit.ts — keep in sync
+import { readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { extractAllSignals } from "./heuristics.js";
+import { collectSession } from "./session-parser.js";
+import { mapSignalsToCompetencies } from "./skill-mapper.js";
+import { detectWorkflows } from "./workflow-detector.js";
+// ---------- Session Discovery ----------
+export function findSessionFiles(dirPath) {
+    const resolved = path.resolve(dirPath);
+    const files = [];
+    function walk(dir) {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry);
+            try {
+                const st = statSync(full);
+                if (st.isDirectory()) {
+                    walk(full);
+                }
+                else if (st.isFile() && entry.endsWith(".jsonl")) {
+                    files.push(full);
+                }
+            }
+            catch {
+                // skip inaccessible entries
+            }
+        }
+    }
+    walk(resolved);
+    return files.sort();
+}
+// ---------- Pipeline ----------
+export async function runAudit(sessionFiles, onProgress) {
+    const allSignals = [];
+    const combined = {
+        messages: [],
+        toolCalls: [],
+        filesTouched: [],
+        allToolCallsBySession: [],
+    };
+    const fileSet = new Set();
+    let signalMs = 0;
+    for (const file of sessionFiles) {
+        onProgress?.({
+            phase: "scan",
+            file: path.basename(file),
+        });
+        const stats = await collectSession(file);
+        combined.messages.push(...stats.messages);
+        combined.toolCalls.push(...stats.toolCalls);
+        combined.allToolCallsBySession.push(stats.toolCalls);
+        for (const fp of stats.filesTouched)
+            fileSet.add(fp);
+        const signalStartedAt = Date.now();
+        allSignals.push(...extractAllSignals(stats));
+        signalMs += Date.now() - signalStartedAt;
+    }
+    combined.filesTouched = [...fileSet];
+    onProgress?.({
+        phase: "signals",
+        current: allSignals.length,
+        total: allSignals.length,
+        elapsedMs: signalMs,
+    });
+    const workflowStartedAt = Date.now();
+    const workflows = detectWorkflows(combined.allToolCallsBySession);
+    onProgress?.({
+        phase: "patterns",
+        current: workflows.length,
+        total: workflows.length,
+        elapsedMs: Date.now() - workflowStartedAt,
+    });
+    const competencies = mapSignalsToCompetencies(allSignals);
+    return {
+        sessionCount: sessionFiles.length,
+        messageCount: combined.messages.length,
+        toolCallCount: combined.toolCalls.length,
+        signalCount: allSignals.length,
+        workflowCount: workflows.length,
+        competencies,
+        workflows,
+        signals: allSignals,
+        combined,
+    };
+}

package/dist/lib/session-parser.d.ts

@@ -0,0 +1,35 @@
+export type ContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: unknown;
+} | {
+    type: "thinking";
+    thinking: string;
+} | {
+    type: "tool_result";
+    tool_use_id: string;
+    content: unknown;
+};
+export type SessionMessage = {
+    uuid: string;
+    timestamp: string;
+    role: "user" | "assistant";
+    content: ContentBlock[];
+    model?: string;
+};
+export type ToolCall = {
+    id: string;
+    name: string;
+    input: unknown;
+};
+export type SessionStats = {
+    messages: SessionMessage[];
+    toolCalls: ToolCall[];
+    filesTouched: string[];
+};
+export declare function parseSession(filePath: string): AsyncGenerator<SessionMessage>;
+export declare function collectSession(filePath: string): Promise<SessionStats>;