@temet/cli 0.3.3 → 0.3.4

package/dist/audit.js

@@ -6,7 +6,7 @@ import { homedir } from "node:os";
 import { basename, join } 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 { findCodexSessionFiles, resolveSessionPath, } from "./lib/path-resolver.js";
 import { trackAuditSnapshot, } from "./lib/audit-tracking.js";
 import { loadMenubarState, resolveLastReportPath, writeMenubarState, } from "./lib/menubar-state.js";
 export function buildAuditJsonOutput(result, competencies, bilan, tracking) {
@@ -276,11 +276,11 @@ function printPretty(result, competencies, bilan, tracking) {
     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 over time`);
+        console.log(`  ${DIM}temet audit --track${RESET}              Keep learning from every Claude Code session`);
     }
-    console.log(`  ${DIM}temet traces${RESET}                          See the proof behind this reading`);
-    console.log(`  ${DIM}temet plan${RESET}                            Turn this audit into a focused next-step plan`);
-    console.log(`  ${DIM}temet audit --path <dir> --publish${RESET}     Publish this audit to your Temet card`);
+    console.log(`  ${DIM}temet traces${RESET}                    See why Temet says this about you`);
+    console.log(`  ${DIM}temet plan${RESET}                      Get one focused next step to improve with AI`);
+    console.log(`  ${DIM}temet audit --publish${RESET}            Share this profile on your Temet card`);
     console.log("");
     console.log(`${ok("Audit complete:", process.stdout)} ${formatCount(competencies.length)} skills surfaced from ${formatCount(result.sessionCount)} sessions`);
     if (tracking) {
@@ -308,6 +308,13 @@ function hasDeclinedHook() {
 function saveHookDeclined() {
     writePrefs({ ...readPrefs(), hookDeclined: true });
 }
+function clearHookDeclined() {
+    const prefs = readPrefs();
+    if (!("hookDeclined" in prefs))
+        return;
+    delete prefs.hookDeclined;
+    writePrefs(prefs);
+}
 function isMacOs() {
     return process.platform === "darwin";
 }
@@ -321,7 +328,7 @@ async function readHookInstalledSafe() {
     }
 }
 // ---------- Confirmation ----------
-async function askYesNo(question, defaultYes, hintOverride) {
+async function askYesNo(question, defaultYes, hintOverride, options) {
     if (!process.stdin.isTTY)
         return false;
     const rl = createInterface({ input: process.stdin, output: process.stderr });
@@ -330,7 +337,13 @@ async function askYesNo(question, defaultYes, hintOverride) {
             ? "Press Enter to continue, or type no to skip:"
             : "Type yes to continue, or press Enter to cancel:");
     return new Promise((resolve) => {
-        rl.question(`\n${BOLD}${question}${RESET}\n${dim(hint, process.stderr)} `, (answer) => {
+        const labelLine = options?.label
+            ? `${colorize("●", CYAN, process.stderr)} ${BOLD}${options.label}${RESET}\n`
+            : "";
+        const descriptionLine = options?.description
+            ? `${dim(options.description, process.stderr)}\n`
+            : "";
+        rl.question(`\n${labelLine}${BOLD}${question}${RESET}\n${descriptionLine}${dim(hint, process.stderr)} `, (answer) => {
             rl.close();
             const trimmed = answer.trim().toLowerCase();
             if (trimmed === "")
@@ -424,6 +437,9 @@ async function publishCompetencies(competencies, opts) {
 }
 // ---------- Main ----------
 export async function runAuditCommand(opts) {
+    if (!opts.json && !opts.quiet) {
+        printBanner();
+    }
     const totalSteps = 4 + (opts.narrate ? 1 : 0) + (opts.publish ? 1 : 0);
     const commandStartedAt = Date.now();
     let resolvedPath = opts.path;
@@ -472,17 +488,26 @@ export async function runAuditCommand(opts) {
             }
         }
     }
+    // Include all Codex sessions from this machine (user-wide audit)
+    const codexFiles = opts.path ? [] : findCodexSessionFiles();
+    if (codexFiles.length > 0) {
+        sessionFiles = [...sessionFiles, ...codexFiles];
+    }
     if (sessionFiles.length === 0) {
         if (!opts.quiet) {
-            console.error(`[temet] no .jsonl session files found in ${resolvedPath}`);
+            console.error("[temet] no AI session files found on this machine");
         }
         process.exit(1);
     }
-    if (!opts.json && !opts.quiet) {
-        printBanner();
-    }
     if (!opts.quiet) {
-        console.error(`[temet] reading ${sessionFiles.length} saved session file(s)...`);
+        const claudeCount = sessionFiles.length - codexFiles.length;
+        const sources = [
+            claudeCount > 0 ? `${claudeCount} Claude` : "",
+            codexFiles.length > 0 ? `${codexFiles.length} Codex` : "",
+        ]
+            .filter(Boolean)
+            .join(" + ");
+        console.error(`[temet] reading ${sessionFiles.length} session file(s)${sources ? ` (${sources})` : ""}`);
     }
     let completedFiles = 0;
     if (!opts.quiet) {
@@ -614,39 +639,57 @@ export async function runAuditCommand(opts) {
             const hookModule = await import("./lib/hook-installer.js");
             const settingsPath = hookModule.getSettingsPath();
             const settings = hookModule.readSettings(settingsPath);
-            const hookAlreadyInstalled = hookModule.isHookInstalled(settings);
-            if (!isMacOs()) {
-                if (!opts.track && !hookAlreadyInstalled && !hasDeclinedHook()) {
-                    const answer = await askYesNo("Keep tracking your skills after each Claude Code session?", true);
-                    if (answer) {
-                        const binary = hookModule.resolveTemetBinary();
-                        if (binary) {
-                            const updated = hookModule.installHook(settings, binary);
-                            hookModule.writeSettings(settingsPath, updated);
-                            console.error(`${ok("Tracking enabled", process.stderr)} ${dim("You'll get a notification when your skills meaningfully change.", process.stderr)}`);
-                        }
-                    }
-                    else {
-                        saveHookDeclined();
+            let hookAlreadyInstalled = hookModule.isHookInstalled(settings);
+            const { isMenubarInstalled, installMenubar } = isMacOs()
+                ? await import("./lib/menubar-installer.js")
+                : {
+                    isMenubarInstalled: () => false,
+                    installMenubar: undefined,
+                };
+            const menubarAlreadyInstalled = isMacOs() ? isMenubarInstalled() : false;
+            if (!hookAlreadyInstalled && !opts.track && !hasDeclinedHook()) {
+                const answer = await askYesNo("Want Temet to keep learning from your Claude Code sessions?", true, "Press Enter to continue (or type no to skip):", {
+                    label: "Continuous learning",
+                    description: "Temet will watch for meaningful changes after each session and keep your progress up to date.",
+                });
+                if (answer) {
+                    const binary = hookModule.resolveTemetBinary();
+                    if (binary) {
+                        const updated = hookModule.installHook(settings, binary);
+                        hookModule.writeSettings(settingsPath, updated);
+                        hookAlreadyInstalled = true;
+                        clearHookDeclined();
+                        console.error(`${ok("✓", process.stderr)} Tracking enabled ${dim("Temet will keep an eye on your progress after each session.", process.stderr)}`);
                     }
                 }
+                else {
+                    saveHookDeclined();
+                }
+            }
+            if (!isMacOs()) {
+                if (hookAlreadyInstalled || opts.track) {
+                    console.error(`${ok("✓", process.stderr)} ${dim("Automatic tracking is already on.", process.stderr)}`);
+                }
             }
             else {
-                const { isMenubarInstalled, installMenubar } = await import("./lib/menubar-installer.js");
-                if (!isMenubarInstalled()) {
-                    const answer = await askYesNo("Show Temet in your menu bar?", true, hookAlreadyInstalled
-                        ? "Press Enter to install Temet, or type no to skip:"
-                        : "Press Enter to install Temet and turn on automatic tracking, or type no to skip:");
+                if (!menubarAlreadyInstalled && installMenubar) {
+                    const answer = await askYesNo("Want Temet to stay visible between sessions?", true, "Press Enter to continue (or type no to skip):", {
+                        label: "Stay visible",
+                        description: "Keep your current focus, recent progress, and latest signals one glance away in your menu bar.",
+                    });
                     if (answer) {
                         const result = await installMenubar({
                             ensureHook: !hookAlreadyInstalled,
                         });
                         const suffix = result.hookInstalled
-                            ? "Temet opened and automatic tracking is now enabled."
-                            : "Temet opened.";
-                        console.error(`${ok("Temet installed", process.stderr)} ${dim(suffix, process.stderr)}`);
+                            ? "Temet is open in your menu bar, and automatic tracking is now on."
+                            : "Temet is open in your menu bar.";
+                        console.error(`${ok("✓", process.stderr)} Temet installed ${dim(suffix, process.stderr)}`);
                     }
                 }
+                else if (menubarAlreadyInstalled) {
+                    console.error(`${ok("✓", process.stderr)} ${dim("Temet is already in your menu bar.", process.stderr)}`);
+                }
             }
         }
         catch (error) {

package/dist/doctor.js

@@ -1,8 +1,8 @@
 import { existsSync } from "node:fs";
 import { basename } from "node:path";
 import { findClaudeProjectCandidates, resolveSessionPath, } from "./lib/path-resolver.js";
-import { getSettingsPath, isHookInstalled, readSettings } from "./lib/hook-installer.js";
-import { getMenubarAppPath, isMenubarInstalled } from "./lib/menubar-installer.js";
+import { getSettingsPath, isHookInstalled, readSettings, } from "./lib/hook-installer.js";
+import { getMenubarAppPath, isMenubarInstalled, } from "./lib/menubar-installer.js";
 import { getMenubarConfigPath, getMenubarStatePath, } from "./lib/menubar-state.js";
 import { resolveAuth } from "./lib/narrator-lite.js";
 import { findSessionFiles } from "./lib/session-audit.js";

package/dist/lib/diagnostic-runner.js

@@ -1,6 +1,6 @@
 import { basename } from "node:path";
 import { createInterface } from "node:readline";
-import { findClaudeProjectCandidates, resolveSessionPath, } from "./path-resolver.js";
+import { findCodexSessionFiles, findClaudeProjectCandidates, resolveSessionPath, } from "./path-resolver.js";
 import { trackAuditSnapshot } from "./audit-tracking.js";
 import { findSessionFiles, runAudit, } from "./session-audit.js";
 async function chooseSessionCandidate(candidates) {
@@ -67,11 +67,28 @@ export async function resolveDiagnostics(opts) {
             }
         }
     }
+    const codexFiles = !opts.path ? findCodexSessionFiles() : [];
+    // Include all Codex sessions (user-wide audit)
+    if (!opts.path) {
+        if (codexFiles.length > 0) {
+            sessionFiles = [...sessionFiles, ...codexFiles];
+        }
+    }
     if (sessionFiles.length === 0) {
-        throw new Error(`No .jsonl session files found in ${resolvedPath}.`);
+        throw new Error(opts.path
+            ? `No .jsonl session files found in ${resolvedPath}.`
+            : "No AI session files found on this machine.");
     }
     if (!opts.quiet) {
-        process.stderr.write(`[temet] reading ${sessionFiles.length} saved session file(s)...\n`);
+        const codexCount = codexFiles.length;
+        const claudeCount = sessionFiles.length - codexCount;
+        const sources = [
+            claudeCount > 0 ? `${claudeCount} Claude` : "",
+            codexCount > 0 ? `${codexCount} Codex` : "",
+        ]
+            .filter(Boolean)
+            .join(" + ");
+        process.stderr.write(`[temet] reading ${sessionFiles.length} session file(s)${sources ? ` (${sources})` : ""}\n`);
     }
     const result = await runAudit(sessionFiles);
     let competencies = result.competencies;

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

@@ -18,6 +18,14 @@ type ResolveSessionPathOptions = {
 /** Convert an absolute project directory to the Claude Code session directory slug. */
 export declare function cwdToSessionDir(cwd: string): string;
 export declare function humanizeSessionDir(sessionDir: string): string;
+export type DetectedSources = {
+    claude: boolean;
+    codex: boolean;
+    claudeCount: number;
+    codexCount: number;
+};
+export declare function detectAvailableSources(claudeRoot?: string, codexRoot?: string): DetectedSources;
+export declare function findCodexSessionFiles(codexRoot?: string): string[];
 export declare function findClaudeProjectCandidates(claudeRoot?: string): SessionCandidate[];
 /**
  * Try to read the JSON stdin from a Claude Code hook (non-blocking).

package/dist/lib/path-resolver.js

@@ -2,6 +2,7 @@ import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
 const DEFAULT_CLAUDE_ROOT = path.join(homedir(), ".claude", "projects");
+const DEFAULT_CODEX_ROOT = path.join(homedir(), ".codex");
 /** Convert an absolute project directory to the Claude Code session directory slug. */
 export function cwdToSessionDir(cwd) {
     const slug = path.resolve(cwd).replace(/\//g, "-");
@@ -51,6 +52,51 @@ function candidateFromSessionDir(sessionDir) {
         updatedAtMs,
     };
 }
+export function detectAvailableSources(claudeRoot = DEFAULT_CLAUDE_ROOT, codexRoot = DEFAULT_CODEX_ROOT) {
+    const claudeCandidates = findClaudeProjectCandidates(claudeRoot);
+    const codexFiles = findCodexSessionFiles(codexRoot);
+    return {
+        claude: claudeCandidates.length > 0,
+        codex: codexFiles.length > 0,
+        claudeCount: claudeCandidates.length,
+        codexCount: codexFiles.length,
+    };
+}
+export function findCodexSessionFiles(codexRoot = DEFAULT_CODEX_ROOT) {
+    const files = [];
+    const dirs = [
+        path.join(codexRoot, "sessions"),
+        path.join(codexRoot, "archived_sessions"),
+    ];
+    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
+            }
+        }
+    }
+    for (const dir of dirs) {
+        walk(dir);
+    }
+    return files.sort();
+}
 export function findClaudeProjectCandidates(claudeRoot = DEFAULT_CLAUDE_ROOT) {
     try {
         return readdirSync(claudeRoot)

package/dist/lib/report-writer.js

@@ -80,7 +80,7 @@ export async function saveAuditTextReport(projectLabel, content, now = new Date(
 }
 export async function openReportFile(filePath, platform = process.platform) {
     if (platform === "darwin") {
-        await execFileAsync("open", ["-a", "TextEdit", filePath]);
+        await execFileAsync("open", [filePath]);
         return;
     }
     if (platform === "win32") {

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

@@ -31,5 +31,7 @@ export type SessionStats = {
     toolCalls: ToolCall[];
     filesTouched: string[];
 };
+export type SessionFormat = "claude" | "codex";
+export declare function detectSessionFormat(firstLine: string): SessionFormat;
 export declare function parseSession(filePath: string): AsyncGenerator<SessionMessage>;
 export declare function collectSession(filePath: string): Promise<SessionStats>;

package/dist/lib/session-parser.js

@@ -65,8 +65,71 @@ function extractFilePathsFromToolInput(input) {
     }
     return paths;
 }
-// ---------- Parser ----------
-export async function* parseSession(filePath) {
+// ---------- Codex helpers ----------
+/** Map Codex tool names to normalized equivalents for heuristic extraction. */
+function mapCodexToolName(name) {
+    switch (name) {
+        case "exec_command":
+        case "shell":
+        case "shell_command":
+            return "Bash";
+        case "apply_patch":
+            return "Edit";
+        case "read_file":
+            return "Read";
+        case "write_stdin":
+            return "Bash";
+        case "update_plan":
+            return "TodoWrite";
+        case "view_image":
+            return "Read";
+        default:
+            return name;
+    }
+}
+function parseCodexArguments(raw) {
+    if (typeof raw === "string") {
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return {};
+        }
+    }
+    if (raw && typeof raw === "object")
+        return raw;
+    return {};
+}
+function normalizeCodexInput(toolName, args) {
+    if (toolName === "exec_command" ||
+        toolName === "shell" ||
+        toolName === "shell_command") {
+        return { command: args.cmd ?? args.command ?? "" };
+    }
+    if (toolName === "apply_patch") {
+        return {
+            file_path: args.file_path ?? args.path ?? "",
+            old_string: "",
+            new_string: "",
+        };
+    }
+    return args;
+}
+export function detectSessionFormat(firstLine) {
+    try {
+        const entry = JSON.parse(firstLine);
+        if (entry.type === "session_meta")
+            return "codex";
+        if (entry.type === "response_item")
+            return "codex";
+    }
+    catch {
+        // fall through
+    }
+    return "claude";
+}
+// ---------- Parsers ----------
+async function* parseClaudeSession(filePath) {
     const stream = createReadStream(filePath, { encoding: "utf-8" });
     const rl = createInterface({
         input: stream,
@@ -103,6 +166,82 @@ export async function* parseSession(filePath) {
         };
     }
 }
+async function* parseCodexSession(filePath) {
+    const stream = createReadStream(filePath, { encoding: "utf-8" });
+    const rl = createInterface({
+        input: stream,
+        crlfDelay: Number.POSITIVE_INFINITY,
+    });
+    for await (const line of rl) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry.type !== "response_item")
+            continue;
+        const payload = entry.payload;
+        if (!payload)
+            continue;
+        const ts = entry.timestamp ?? "";
+        // User or assistant text messages
+        if (payload.type === "message") {
+            const role = payload.role;
+            if (role !== "user" && role !== "assistant")
+                continue;
+            const content = normalizeContent(payload.content);
+            if (content.length === 0)
+                continue;
+            yield { uuid: "", timestamp: ts, role, content };
+            continue;
+        }
+        // Function calls → normalize to tool_use
+        if (payload.type === "function_call" && typeof payload.name === "string") {
+            const args = parseCodexArguments(payload.arguments);
+            const mappedName = mapCodexToolName(payload.name);
+            const input = normalizeCodexInput(payload.name, args);
+            yield {
+                uuid: payload.call_id ?? "",
+                timestamp: ts,
+                role: "assistant",
+                content: [
+                    {
+                        type: "tool_use",
+                        id: payload.call_id ?? "",
+                        name: mappedName,
+                        input,
+                    },
+                ],
+            };
+        }
+    }
+}
+export async function* parseSession(filePath) {
+    const stream = createReadStream(filePath, { encoding: "utf-8" });
+    const rl = createInterface({
+        input: stream,
+        crlfDelay: Number.POSITIVE_INFINITY,
+    });
+    let format = null;
+    for await (const line of rl) {
+        if (!line.trim())
+            continue;
+        format = detectSessionFormat(line);
+        break;
+    }
+    // Close the detection stream, re-open with the right parser
+    stream.destroy();
+    if (format === "codex") {
+        yield* parseCodexSession(filePath);
+    }
+    else {
+        yield* parseClaudeSession(filePath);
+    }
+}
 export async function collectSession(filePath) {
     const messages = [];
     const toolCalls = [];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@temet/cli",
-	"version": "0.3.3",
+	"version": "0.3.4",
 	"description": "Temet CLI — discover the skills you already demonstrate in AI work",
 	"keywords": [
 		"temet",