@temet/cli 0.2.0 → 0.3.1

package/dist/lib/workflow-detector.js

@@ -0,0 +1,125 @@
+// ---------- Named Patterns ----------
+const NAMED_PATTERNS = [
+    { tools: ["Grep", "Read", "Edit"], name: "Search-Understand-Modify" },
+    { tools: ["Read", "Edit", "Bash"], name: "Read-Modify-Test" },
+    { tools: ["Glob", "Read", "Edit"], name: "Find-Read-Edit" },
+    { tools: ["Read", "Edit", "Read"], name: "Read-Edit-Verify" },
+    { tools: ["Bash", "Read", "Edit"], name: "Run-Read-Fix" },
+    { tools: ["Grep", "Read", "Edit", "Bash"], name: "Search-Read-Edit-Test" },
+];
+function nameWorkflow(sequence) {
+    for (const p of NAMED_PATTERNS) {
+        if (p.tools.length === sequence.length &&
+            p.tools.every((t, i) => t === sequence[i])) {
+            return p.name;
+        }
+    }
+    return sequence.join(" \u2192 ");
+}
+// ---------- Helpers ----------
+/** Collapse consecutive identical tool names: [Read, Read, Read, Edit] → [Read, Edit] */
+function dedup(tools) {
+    const result = [];
+    for (const t of tools) {
+        if (result[result.length - 1] !== t) {
+            result.push(t);
+        }
+    }
+    return result;
+}
+function extractToolNames(toolCalls) {
+    return toolCalls.map((tc) => tc.name);
+}
+function ngramKey(seq) {
+    return seq.join("::");
+}
+function generateNgrams(tools, n, sessionIdx, acc) {
+    for (let i = 0; i <= tools.length - n; i++) {
+        const gram = tools.slice(i, i + n);
+        const key = ngramKey(gram);
+        const existing = acc.get(key);
+        if (existing) {
+            existing.occurrences++;
+            existing.sessions.add(sessionIdx);
+        }
+        else {
+            acc.set(key, { occurrences: 1, sessions: new Set([sessionIdx]) });
+        }
+    }
+}
+/**
+ * Remove n-grams that are fully explained by a single longer qualifying n-gram.
+ * Uses max (not sum) of explanations from individual longer patterns to avoid
+ * double-counting when overlapping longer n-grams explain the same instances.
+ */
+function collapseSubsumed(ngrams) {
+    const keys = [...ngrams.keys()].sort((a, b) => b.split("::").length - a.split("::").length);
+    const kept = new Map();
+    // Track the max occurrences any single longer n-gram can explain for each shorter one
+    const maxExplained = new Map();
+    for (const key of keys) {
+        const info = ngrams.get(key);
+        const explained = maxExplained.get(key) ?? 0;
+        // If a single longer n-gram accounts for all occurrences, skip
+        if (explained >= info.occurrences)
+            continue;
+        kept.set(key, info);
+        // Record how many occurrences this pattern can explain for each sub-sequence
+        const parts = key.split("::");
+        for (let len = parts.length - 1; len >= 3; len--) {
+            for (let start = 0; start <= parts.length - len; start++) {
+                const sub = ngramKey(parts.slice(start, start + len));
+                if (ngrams.has(sub)) {
+                    const current = maxExplained.get(sub) ?? 0;
+                    if (info.occurrences > current) {
+                        maxExplained.set(sub, info.occurrences);
+                    }
+                }
+            }
+        }
+    }
+    return kept;
+}
+// ---------- Main ----------
+export function detectWorkflows(allToolCalls) {
+    if (allToolCalls.length === 0)
+        return [];
+    const ngrams = new Map();
+    for (let si = 0; si < allToolCalls.length; si++) {
+        const tools = dedup(extractToolNames(allToolCalls[si]));
+        for (const n of [5, 4, 3]) {
+            generateNgrams(tools, n, si, ngrams);
+        }
+    }
+    // Filter: 3+ occurrences AND 2+ distinct sessions
+    for (const [key, info] of ngrams) {
+        if (info.occurrences < 3 || info.sessions.size < 2) {
+            ngrams.delete(key);
+        }
+    }
+    const collapsed = collapseSubsumed(ngrams);
+    const workflows = [];
+    for (const [key, info] of collapsed) {
+        const sequence = key.split("::");
+        const confidence = Math.min(0.5 + info.occurrences * 0.05 + info.sessions.size * 0.1, 0.95);
+        workflows.push({
+            sequence,
+            occurrences: info.occurrences,
+            sessions: info.sessions.size,
+            confidence,
+            description: nameWorkflow(sequence),
+        });
+    }
+    // Sort by confidence desc
+    workflows.sort((a, b) => b.confidence - a.confidence);
+    return workflows;
+}
+export function workflowsToSignals(workflows) {
+    return workflows.map((w) => ({
+        type: "workflow",
+        skill: w.description,
+        confidence: w.confidence,
+        evidence: `Workflow [${w.sequence.join(" \u2192 ")}] detected ${w.occurrences} times across ${w.sessions} sessions`,
+        category: "methodology",
+    }));
+}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@temet/cli",
-	"version": "0.2.0",
-	"description": "Temet CLI for MCP configuration",
+	"version": "0.3.1",
+	"description": "Temet CLI — discover the skills you already demonstrate in AI work",
 	"keywords": [
 		"temet",
 		"mcp",