@temet/cli 0.2.0 → 0.3.1

package/dist/lib/report-writer.js

@@ -0,0 +1,73 @@
+import { execFile } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { buildSkillAuditReport } from "./profile-report.js";
+const execFileAsync = promisify(execFile);
+const TEMET_WORDMARK = [
+    "████████╗███████╗███╗   ███╗███████╗████████╗",
+    "╚══██╔══╝██╔════╝████╗ ████║██╔════╝╚══██╔══╝",
+    "   ██║   █████╗  ██╔████╔██║█████╗     ██║   ",
+    "   ██║   ██╔══╝  ██║╚██╔╝██║██╔══╝     ██║   ",
+    "   ██║   ███████╗██║ ╚═╝ ██║███████╗   ██║   ",
+    "   ╚═╝   ╚══════╝╚═╝     ╚═╝╚══════╝   ╚═╝   ",
+];
+function divider(char = "─", width = 66) {
+    return char.repeat(width);
+}
+function section(title, body) {
+    return [title, divider(), "", ...body, ""];
+}
+export function buildAuditTextReport(result, competencies, bilan, tracking) {
+    const lines = [];
+    const profile = buildSkillAuditReport(result, competencies, tracking);
+    lines.push(...TEMET_WORDMARK, "", "By Temet · Encode human intelligence", "temet-skills-audit", "", profile.title, "", profile.subtitle, "");
+    lines.push(...section(`YOUR ${profile.tacitSkills.length} TACIT SKILLS`, profile.tacitSkills.flatMap((entry, index) => {
+        const header = entry.tagline
+            ? `${index + 1}. ${entry.title} — ${entry.tagline}`
+            : `${index + 1}. ${entry.title}`;
+        return [header, "", entry.body, ""];
+    })));
+    if (profile.meaningfulChanges.length > 0) {
+        lines.push(...section("WHAT CHANGED SINCE THE LAST AUDIT", profile.meaningfulChanges));
+    }
+    lines.push(...section("YOUR 3 BLIND SPOTS", profile.blindSpots.flatMap((entry, index) => [
+        `${index + 1}. ${entry.title}`,
+        "",
+        entry.body,
+        "",
+    ])));
+    lines.push(...section("YOUR PROFESSIONAL DNA", [
+        bilan?.trim() || profile.professionalDna,
+    ]));
+    lines.push(...section("THE META-SKILL THAT TIES IT ALL TOGETHER", [
+        profile.metaSkill.title,
+        "",
+        profile.metaSkill.body,
+    ]));
+    lines.push(divider(), "", "Thanks for reading.", "Arnaud");
+    return `${lines.join("\n").trim()}\n`;
+}
+export function buildReportPath(projectLabel, now = new Date()) {
+    const date = now.toISOString().replace(/:/g, "-");
+    const safeLabel = projectLabel.replace(/[^a-zA-Z0-9._-]+/g, "-");
+    return path.join(homedir(), ".temet", "reports", safeLabel, `temet-skills-audit-${date}.txt`);
+}
+export async function saveAuditTextReport(projectLabel, content, now = new Date()) {
+    const filePath = buildReportPath(projectLabel, now);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, "utf8");
+    return filePath;
+}
+export async function openReportFile(filePath, platform = process.platform) {
+    if (platform === "darwin") {
+        await execFileAsync("open", ["-a", "TextEdit", filePath]);
+        return;
+    }
+    if (platform === "win32") {
+        await execFileAsync("notepad", [filePath]);
+        return;
+    }
+    await execFileAsync("xdg-open", [filePath]);
+}

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

@@ -0,0 +1,24 @@
+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;
+    promptCount: 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,94 @@
+// 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);
+    const promptCount = combined.messages.filter((message) => message.role === "user").length;
+    return {
+        sessionCount: sessionFiles.length,
+        messageCount: combined.messages.length,
+        promptCount,
+        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>;

package/dist/lib/session-parser.js

@@ -0,0 +1,130 @@
+// Adapted from scripts/lib/session-parser.ts — keep in sync
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+// ---------- Helpers ----------
+function normalizeContent(raw) {
+    if (typeof raw === "string") {
+        return [{ type: "text", text: raw }];
+    }
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .map((block) => {
+        if (typeof block === "string") {
+            return { type: "text", text: block };
+        }
+        if (!block || typeof block !== "object")
+            return null;
+        const b = block;
+        if (b.type === "text" && typeof b.text === "string") {
+            return { type: "text", text: b.text };
+        }
+        if (b.type === "tool_use" && typeof b.name === "string") {
+            return {
+                type: "tool_use",
+                id: b.id ?? "",
+                name: b.name,
+                input: b.input,
+            };
+        }
+        if (b.type === "thinking" && typeof b.thinking === "string") {
+            return { type: "thinking", thinking: b.thinking };
+        }
+        if (b.type === "tool_result") {
+            return {
+                type: "tool_result",
+                tool_use_id: b.tool_use_id ?? "",
+                content: b.content,
+            };
+        }
+        return null;
+    })
+        .filter((b) => b !== null);
+}
+function extractFilePathsFromToolInput(input) {
+    if (!input || typeof input !== "object")
+        return [];
+    const paths = [];
+    const inp = input;
+    for (const key of ["file_path", "path", "filePath", "pattern"]) {
+        if (typeof inp[key] === "string" && inp[key]) {
+            const val = inp[key];
+            if (val.startsWith("/") || val.includes("/")) {
+                paths.push(val);
+            }
+        }
+    }
+    if (typeof inp.command === "string") {
+        const cmd = inp.command;
+        const pathMatches = cmd.match(/(?:^|\s)(\/[^\s;|&>]+)/g);
+        if (pathMatches) {
+            for (const m of pathMatches) {
+                paths.push(m.trim());
+            }
+        }
+    }
+    return paths;
+}
+// ---------- Parser ----------
+export async function* parseSession(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;
+        }
+        const entryType = entry.type;
+        if (entryType !== "user" && entryType !== "assistant")
+            continue;
+        const message = entry.message;
+        if (!message || typeof message !== "object")
+            continue;
+        const role = message.role;
+        if (role !== "user" && role !== "assistant")
+            continue;
+        const content = normalizeContent(message.content);
+        if (content.length === 0)
+            continue;
+        yield {
+            uuid: entry.uuid ?? "",
+            timestamp: entry.timestamp ?? "",
+            role,
+            content,
+            model: role === "assistant" ? message.model : undefined,
+        };
+    }
+}
+export async function collectSession(filePath) {
+    const messages = [];
+    const toolCalls = [];
+    const fileSet = new Set();
+    for await (const msg of parseSession(filePath)) {
+        messages.push(msg);
+        for (const block of msg.content) {
+            if (block.type === "tool_use") {
+                toolCalls.push({
+                    id: block.id,
+                    name: block.name,
+                    input: block.input,
+                });
+                for (const fp of extractFilePathsFromToolInput(block.input)) {
+                    fileSet.add(fp);
+                }
+            }
+        }
+    }
+    return {
+        messages,
+        toolCalls,
+        filesTouched: [...fileSet],
+    };
+}

package/dist/lib/skill-mapper.d.ts

@@ -0,0 +1,3 @@
+import type { CompetencyEntry } from "./types.js";
+import type { Signal } from "./heuristics.js";
+export declare function mapSignalsToCompetencies(signals: Signal[]): CompetencyEntry[];

package/dist/lib/skill-mapper.js

@@ -0,0 +1,173 @@
+// Adapted from scripts/lib/skill-mapper.ts — keep in sync
+import { createHash } from "node:crypto";
+import { toDisplaySkillName } from "./skill-naming.js";
+// ---------- Normalization ----------
+function normalizeSkillName(name) {
+    return name.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function makeId(name) {
+    const hash = createHash("sha256").update(name).digest("hex").slice(0, 8);
+    const slug = normalizeSkillName(name)
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/-+$/, "");
+    return `session-${slug}-${hash}`;
+}
+// ---------- Proficiency Mapping ----------
+function computeProficiency(signals) {
+    if (signals.length === 0)
+        return "novice";
+    // Average confidence weighted by signal count
+    const avgConfidence = signals.reduce((sum, s) => sum + s.confidence, 0) / signals.length;
+    // More signals from different extractors = more evidence
+    const uniqueTypes = new Set(signals.map((s) => s.type)).size;
+    const diversityBonus = Math.min(uniqueTypes * 0.1, 0.3);
+    const score = avgConfidence + diversityBonus;
+    if (score >= 0.9)
+        return "expert";
+    if (score >= 0.75)
+        return "proficient";
+    if (score >= 0.55)
+        return "competent";
+    if (score >= 0.35)
+        return "advanced_beginner";
+    return "novice";
+}
+function resolveCategory(signals) {
+    // Take the most common category from signals
+    const counts = new Map();
+    for (const s of signals) {
+        if (s.category) {
+            counts.set(s.category, (counts.get(s.category) ?? 0) + 1);
+        }
+    }
+    let best = "hard_skill";
+    let bestCount = 0;
+    for (const [cat, count] of counts) {
+        if (count > bestCount) {
+            best = cat;
+            bestCount = count;
+        }
+    }
+    return best;
+}
+// ---------- Evidence Builder ----------
+function buildEvidence(signals) {
+    const examples = [];
+    const decisionCriteria = [];
+    const antiPatterns = [];
+    const mentorAdvice = [];
+    for (const s of signals) {
+        switch (s.type) {
+            case "correction":
+                antiPatterns.push(s.evidence);
+                break;
+            case "decision_language":
+                if (s.evidence.startsWith("Anti-pattern")) {
+                    antiPatterns.push(s.evidence);
+                }
+                else {
+                    decisionCriteria.push(s.evidence);
+                }
+                break;
+            case "tool_frequency":
+            case "domain_cluster":
+                examples.push(s.evidence);
+                break;
+            case "workflow":
+                examples.push(s.evidence);
+                break;
+            case "prompt_structure":
+                mentorAdvice.push(s.evidence);
+                break;
+            default:
+                examples.push(s.evidence);
+        }
+    }
+    return { examples, decisionCriteria, antiPatterns, mentorAdvice };
+}
+function buildDescription(name, signals) {
+    const types = [...new Set(signals.map((s) => s.type))];
+    const sources = types
+        .map((t) => {
+        switch (t) {
+            case "correction":
+                return "user corrections";
+            case "tool_frequency":
+                return "tool usage patterns";
+            case "decision_language":
+                return "stated preferences";
+            case "domain_cluster":
+                return "domain focus";
+            case "prompt_structure":
+                return "prompt patterns";
+            default:
+                return t;
+        }
+    })
+        .join(", ");
+    return `Detected from ${signals.length} signal(s) via ${sources}. Skill: ${name}.`;
+}
+// ---------- Synergy Detection ----------
+function detectSynergies(groups, current) {
+    const synergies = [];
+    const currentFiles = new Set(current.signals
+        .filter((s) => s.type === "domain_cluster")
+        .map((s) => s.skill));
+    const currentTools = new Set(current.signals
+        .filter((s) => s.type === "tool_frequency")
+        .map((s) => s.skill));
+    for (const other of groups) {
+        if (other.normalizedName === current.normalizedName)
+            continue;
+        // Skills in the same domain or using the same tools likely synergize
+        const otherDomains = other.signals
+            .filter((s) => s.type === "domain_cluster")
+            .map((s) => s.skill);
+        const otherTools = other.signals
+            .filter((s) => s.type === "tool_frequency")
+            .map((s) => s.skill);
+        const domainOverlap = otherDomains.some((d) => currentFiles.has(d));
+        const toolOverlap = otherTools.some((t) => currentTools.has(t));
+        if (domainOverlap || toolOverlap) {
+            synergies.push(other.normalizedName);
+        }
+    }
+    return synergies.slice(0, 5);
+}
+// ---------- Main Mapper ----------
+export function mapSignalsToCompetencies(signals) {
+    // Group by normalized skill name
+    const groupMap = new Map();
+    for (const s of signals) {
+        const displayName = toDisplaySkillName(s.skill);
+        const key = normalizeSkillName(displayName);
+        const group = groupMap.get(key);
+        if (group) {
+            group.push(s);
+        }
+        else {
+            groupMap.set(key, [s]);
+        }
+    }
+    const groups = [...groupMap.entries()].map(([normalizedName, sigs]) => ({
+        normalizedName,
+        displayName: toDisplaySkillName(sigs[0]?.skill ?? normalizedName),
+        signals: sigs,
+    }));
+    return groups.map((group) => {
+        const proficiencyLevel = computeProficiency(group.signals);
+        const category = resolveCategory(group.signals);
+        const evidence = buildEvidence(group.signals);
+        const synergies = detectSynergies(groups, group);
+        return {
+            id: makeId(group.displayName),
+            name: group.displayName,
+            category,
+            proficiencyLevel,
+            description: buildDescription(group.displayName, group.signals),
+            evidence,
+            prerequisites: [],
+            synergies,
+        };
+    });
+}

package/dist/lib/skill-naming.d.ts

@@ -0,0 +1 @@
+export declare function toDisplaySkillName(name: string): string;

package/dist/lib/skill-naming.js

@@ -0,0 +1,50 @@
+const DISPLAY_NAME_MAP = {
+    "agent-to-agent protocol": "Agent-to-agent protocol design",
+    "ai/llm integration": "AI product and model integration",
+    "api design": "API boundary and contract design",
+    "api integration": "External API exploration and integration",
+    "build tooling and automation": "Build tooling and automation design",
+    "chat application architecture": "Chat product architecture",
+    "ci/cd pipeline design": "CI/CD pipeline design",
+    "cloudflare workers development": "Cloudflare Workers delivery",
+    "code archaeology": "Codebase archaeology across large repositories",
+    "code comprehension": "Deep code comprehension before change",
+    "code editing precision": "Precise refactoring across complex dependencies",
+    "code generation": "Structured code generation from specs",
+    "code review judgment": "Code review judgment under ambiguity",
+    "code style standards": "Code style and consistency standards",
+    "competency modeling": "Competency modeling and skill structuring",
+    "component architecture": "Component architecture and UI structure",
+    "content strategy": "Content strategy and editorial structuring",
+    "database design": "Database schema and query design",
+    "engineering judgment": "Engineering judgment under ambiguity",
+    "error handling strategy": "Error handling and failure-path strategy",
+    "generative ui systems": "Generative UI system design",
+    "performance optimization": "Performance optimization and responsiveness",
+    "rapid iteration workflow": "Rapid iteration under tight feedback loops",
+    "react component development": "System-aware React component development",
+    "research methodology": "Focused research and source triage",
+    "security awareness": "Security-aware implementation review",
+    "security practices": "Security-conscious engineering decisions",
+    "shell scripting": "Command-line execution and shell troubleshooting",
+    "software architecture": "Software architecture and system boundaries",
+    "specification methodology": "Spec-driven implementation planning",
+    "task delegation": "Delegating subtasks to AI agents",
+    "testing methodology": "Test-driven delivery discipline",
+    "type system design": "Type system design and schema rigor",
+    "ui/ux design sense": "UI judgment and interaction clarity",
+    "version control judgment": "Version control judgment in risky changes",
+    "version control mastery": "Version control execution in active worktrees",
+    "version control workflow": "Version control workflow hygiene",
+};
+function titleCase(raw) {
+    return raw
+        .split(/\s+/)
+        .filter(Boolean)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(" ");
+}
+export function toDisplaySkillName(name) {
+    const normalized = name.toLowerCase().replace(/\s+/g, " ").trim();
+    return DISPLAY_NAME_MAP[normalized] ?? titleCase(normalized);
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,17 @@
+export type ProficiencyLevel = "novice" | "advanced_beginner" | "competent" | "proficient" | "expert";
+export type CompetencyCategory = "hard_skill" | "soft_skill" | "domain_knowledge" | "tool_proficiency" | "methodology" | "judgment";
+export type CompetencyEntry = {
+    id: string;
+    name: string;
+    category: CompetencyCategory;
+    proficiencyLevel: ProficiencyLevel;
+    description: string;
+    evidence: {
+        examples: string[];
+        decisionCriteria: string[];
+        antiPatterns: string[];
+        mentorAdvice: string[];
+    };
+    prerequisites: string[];
+    synergies: string[];
+};

package/dist/lib/types.js

@@ -0,0 +1,2 @@
+// Inlined from lib/competency/taxonomy.ts — keep in sync
+export {};

package/dist/lib/workflow-detector.d.ts

@@ -0,0 +1,11 @@
+import type { Signal } from "./heuristics.js";
+import type { ToolCall } from "./session-parser.js";
+export type DetectedWorkflow = {
+    sequence: string[];
+    occurrences: number;
+    sessions: number;
+    confidence: number;
+    description: string;
+};
+export declare function detectWorkflows(allToolCalls: ToolCall[][]): DetectedWorkflow[];
+export declare function workflowsToSignals(workflows: DetectedWorkflow[]): Signal[];