@temet/cli 0.3.1 → 0.3.3

package/dist/plan.js

@@ -0,0 +1,90 @@
+import { resolveDiagnostics } from "./lib/diagnostic-runner.js";
+import { buildSkillAuditReport } from "./lib/profile-report.js";
+function actionForBlindSpot(title) {
+    switch (title) {
+        case "Feature sprawl":
+            return {
+                title,
+                action: "Finish one live path before opening another new direction this week.",
+                reason: "Your output is not the constraint. Selection and closure are.",
+            };
+        case "Git hygiene under pressure":
+            return {
+                title,
+                action: "Reduce branch churn and land one clean, reviewable slice before the next risky change.",
+                reason: "The skill is there; the failure mode is pressure, not ignorance.",
+            };
+        case "Technical detours":
+            return {
+                title,
+                action: "Timebox deep exploration and force a product decision when the learning curve flattens.",
+                reason: "Curiosity is helping you, but it still needs a stopping rule.",
+            };
+        case "Coordination drag":
+            return {
+                title,
+                action: "Write the one-line decision and owner before you expand the system further.",
+                reason: "Alignment cost is starting to compete with build cost.",
+            };
+        default:
+            return {
+                title,
+                action: "Keep the loop short and choose one concrete improvement to test next.",
+                reason: "The report points to a leverage point, not a reason to add more layers.",
+            };
+    }
+}
+function buildPlanItems(blindSpots, meaningfulChanges) {
+    const items = blindSpots
+        .slice(0, 3)
+        .map((spot) => actionForBlindSpot(spot.title));
+    if (meaningfulChanges.length > 0) {
+        items.push({
+            title: "Recent movement",
+            action: "Protect the newest positive change and turn it into a repeated habit.",
+            reason: meaningfulChanges[0] ?? "A new pattern just surfaced; reinforce it.",
+        });
+    }
+    return items.slice(0, 3);
+}
+export function buildPlanJsonOutput(input) {
+    return input;
+}
+function printPlan(output) {
+    console.log("PLAN");
+    console.log("");
+    console.log(output.professionalDna);
+    console.log("");
+    console.log("Keep");
+    for (const item of output.keep) {
+        console.log(`  - ${item.title}${item.tagline ? ` — ${item.tagline}` : ""}`);
+    }
+    console.log("");
+    console.log("Watch");
+    for (const item of output.watch) {
+        console.log(`  - ${item.title}: ${item.body}`);
+    }
+    console.log("");
+    console.log("Plan");
+    for (const item of output.plan) {
+        console.log(`  - ${item.action}`);
+        console.log(`    Why: ${item.reason}`);
+    }
+}
+export async function runPlanCommand(opts) {
+    const diagnostics = await resolveDiagnostics(opts);
+    if (opts.quiet)
+        return;
+    const report = buildSkillAuditReport(diagnostics.result, diagnostics.competencies, diagnostics.tracking);
+    const output = buildPlanJsonOutput({
+        professionalDna: diagnostics.bilan?.trim() || report.professionalDna,
+        keep: report.tacitSkills.slice(0, 3),
+        watch: report.blindSpots.slice(0, 3),
+        plan: buildPlanItems(report.blindSpots, report.meaningfulChanges),
+    });
+    if (opts.json) {
+        console.log(JSON.stringify(output, null, 2));
+        return;
+    }
+    printPlan(output);
+}

package/dist/traces.d.ts

@@ -0,0 +1,41 @@
+import type { AuditCliOptions } from "./lib/cli-args.js";
+import type { CompetencyEntry } from "./lib/types.js";
+type EvidenceItem = {
+    kind: "example" | "decision" | "anti_pattern" | "mentor";
+    text: string;
+};
+export declare function buildTracesJsonOutput(input: {
+    projectLabel: string;
+    sessions: number;
+    prompts: number;
+    toolCalls: number;
+    competencies: CompetencyEntry[];
+    workflows: Array<{
+        description: string;
+        sequence: string[];
+        occurrences: number;
+        sessions: number;
+        confidence: number;
+    }>;
+}): {
+    project: string;
+    sessions: number;
+    prompts: number;
+    toolCalls: number;
+    competencies: {
+        name: string;
+        category: import("./lib/types.js").CompetencyCategory;
+        proficiencyLevel: import("./lib/types.js").ProficiencyLevel;
+        description: string;
+        evidence: EvidenceItem[];
+    }[];
+    workflows: {
+        description: string;
+        sequence: string[];
+        occurrences: number;
+        sessions: number;
+        confidence: number;
+    }[];
+};
+export declare function runTracesCommand(opts: AuditCliOptions): Promise<void>;
+export {};

package/dist/traces.js

@@ -0,0 +1,119 @@
+import { defaultProjectLabel, resolveDiagnostics, } from "./lib/diagnostic-runner.js";
+function evidenceCount(entry) {
+    return (entry.evidence.examples.length +
+        entry.evidence.decisionCriteria.length +
+        entry.evidence.antiPatterns.length +
+        entry.evidence.mentorAdvice.length);
+}
+function proficiencyScore(level) {
+    switch (level) {
+        case "expert":
+            return 5;
+        case "proficient":
+            return 4;
+        case "competent":
+            return 3;
+        case "advanced_beginner":
+            return 2;
+        default:
+            return 1;
+    }
+}
+function topCompetencies(competencies, limit = 6) {
+    return [...competencies]
+        .sort((a, b) => {
+        const scoreDiff = proficiencyScore(b.proficiencyLevel) -
+            proficiencyScore(a.proficiencyLevel);
+        if (scoreDiff !== 0)
+            return scoreDiff;
+        return evidenceCount(b) - evidenceCount(a);
+    })
+        .slice(0, limit);
+}
+function flattenEvidence(entry) {
+    return [
+        ...entry.evidence.examples.map((text) => ({
+            kind: "example",
+            text,
+        })),
+        ...entry.evidence.decisionCriteria.map((text) => ({
+            kind: "decision",
+            text,
+        })),
+        ...entry.evidence.antiPatterns.map((text) => ({
+            kind: "anti_pattern",
+            text,
+        })),
+        ...entry.evidence.mentorAdvice.map((text) => ({
+            kind: "mentor",
+            text,
+        })),
+    ].slice(0, 6);
+}
+function kindLabel(kind) {
+    switch (kind) {
+        case "example":
+            return "example";
+        case "decision":
+            return "decision";
+        case "anti_pattern":
+            return "anti-pattern";
+        case "mentor":
+            return "signal";
+    }
+}
+export function buildTracesJsonOutput(input) {
+    return {
+        project: input.projectLabel,
+        sessions: input.sessions,
+        prompts: input.prompts,
+        toolCalls: input.toolCalls,
+        competencies: topCompetencies(input.competencies).map((entry) => ({
+            name: entry.name,
+            category: entry.category,
+            proficiencyLevel: entry.proficiencyLevel,
+            description: entry.description,
+            evidence: flattenEvidence(entry),
+        })),
+        workflows: input.workflows.slice(0, 5),
+    };
+}
+function printTraces(input) {
+    console.log("TRACES");
+    console.log("");
+    console.log(`${input.project} · ${input.sessions} sessions · ${input.prompts} prompts · ${input.toolCalls} tool calls`);
+    console.log("");
+    for (const entry of input.competencies) {
+        console.log(`${entry.name} · ${entry.proficiencyLevel}`);
+        console.log(`  ${entry.description}`);
+        for (const item of entry.evidence) {
+            console.log(`  - ${kindLabel(item.kind)}: ${item.text}`);
+        }
+        console.log("");
+    }
+    if (input.workflows.length > 0) {
+        console.log("Repeated patterns");
+        for (const workflow of input.workflows) {
+            console.log(`  - ${workflow.description} · ${workflow.occurrences} occurrences across ${workflow.sessions} sessions`);
+        }
+    }
+}
+export async function runTracesCommand(opts) {
+    const diagnostics = await resolveDiagnostics(opts);
+    if (opts.quiet)
+        return;
+    const output = buildTracesJsonOutput({
+        projectLabel: diagnostics.tracking?.current.projectLabel ??
+            defaultProjectLabel(diagnostics.resolvedPath),
+        sessions: diagnostics.result.sessionCount,
+        prompts: diagnostics.result.promptCount,
+        toolCalls: diagnostics.result.toolCallCount,
+        competencies: diagnostics.competencies,
+        workflows: diagnostics.result.workflows,
+    });
+    if (opts.json) {
+        console.log(JSON.stringify(output, null, 2));
+        return;
+    }
+    printTraces(output);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@temet/cli",
-	"version": "0.3.1",
+	"version": "0.3.3",
 	"description": "Temet CLI — discover the skills you already demonstrate in AI work",
 	"keywords": [
 		"temet",
@@ -24,7 +24,8 @@
 		"temet": "dist/index.js"
 	},
 	"files": [
-		"dist"
+		"dist",
+		"assets"
 	],
 	"scripts": {
 		"build": "tsc -p tsconfig.json",