infernoflow 0.33.0 → 0.34.0

package/dist/lib/git/detect-drift.mjs

@@ -1,4 +1,208 @@
-import*as p from"node:fs";import*as m from"node:path";import{execSync as F}from"node:child_process";function k(i,o={}){const{sinceCommits:d=1,includeStagedOnly:l=!1}=o,r=new Set;try{const f=F("git diff --name-only HEAD",{cwd:i,encoding:"utf8",timeout:1e4});for(const c of f.split(`
-`).map(n=>n.trim()).filter(Boolean))r.add(c)}catch{}try{const f=F(`git diff --name-only HEAD~${d} HEAD`,{cwd:i,encoding:"utf8",timeout:1e4});for(const c of f.split(`
-`).map(n=>n.trim()).filter(Boolean))r.add(c)}catch{}try{const f=F("git ls-files --others --exclude-standard",{cwd:i,encoding:"utf8",timeout:1e4});for(const c of f.split(`
-`).map(n=>n.trim()).filter(Boolean))r.add(c)}catch{}return Array.from(r).sort()}function C(i){const o=m.join(i,"capability-map.json");if(!p.existsSync(o))return null;try{return JSON.parse(p.readFileSync(o,"utf8"))}catch{return null}}function x(i){const o=m.join(i,"adoption_profile.json");if(!p.existsSync(o))return null;try{return JSON.parse(p.readFileSync(o,"utf8"))}catch{return null}}function j(i){const o=m.join(i,"capabilities.json");if(!p.existsSync(o))return[];try{return JSON.parse(p.readFileSync(o,"utf8")).capabilities||[]}catch{return[]}}function A(i,o={}){const d=m.join(i,"inferno"),l=k(i,o);if(!l.length)return{changedFiles:[],affectedCapabilities:[],unmappedFiles:[],hasCapabilityMap:!1};const r=C(d),f=x(d),c=j(d),n=new Map,y=(e,s)=>{n.has(e.id)||n.set(e.id,{id:e.id,title:e.title||e.id,matchedFiles:new Set}),n.get(e.id).matchedFiles.add(s)},h=new Set;if(r){for(const e of l)for(const[s,t]of Object.entries(r))if(e.startsWith(s.replace(/\\/g,"/")))for(const a of t){const u=c.find(b=>b.id===a)||{id:a,title:a};y(u,e),h.add(e)}}const g=[];if(f){const e=m.join(d,"capabilities.json");try{const s=JSON.parse(p.readFileSync(e,"utf8"));for(const t of s.capabilities||[])t.sourceFiles&&t.sourceFiles.length>0&&g.push(t)}catch{}}if(g.length>0)for(const e of g)for(const s of e.sourceFiles||[]){const t=s.replace(/\\/g,"/");for(const a of l){const u=a.replace(/\\/g,"/");(u===t||u.startsWith(m.dirname(t)+"/"))&&(y(e,a),h.add(a))}}const I=[{keywords:["search"],capId:"SearchItems"},{keywords:["filter"],capId:"FilterItems"},{keywords:["auth","login","logout","signin","signup"],capId:"Authentication"},{keywords:["create","add","new"],capId:"CreateItem"},{keywords:["update","edit"],capId:"UpdateItem"},{keywords:["delete","remove"],capId:"DeleteItem"},{keywords:["read","list","view"],capId:"ReadItems"},{keywords:["due","deadline","date"],capId:"SetDueDate"},{keywords:["priority"],capId:"SetPriority"},{keywords:["complete","done","toggle"],capId:"ToggleComplete"}];for(const e of l){if(h.has(e))continue;const s=e.toLowerCase();for(const t of I)if(t.keywords.some(a=>s.includes(a))){const a=c.find(u=>u.id===t.capId)||{id:t.capId,title:t.capId};y(a,e),h.add(e);break}}const S=l.filter(e=>!h.has(e)),w=Array.from(n.values()).map(e=>({id:e.id,title:e.title,matchedFiles:Array.from(e.matchedFiles),confidence:e.matchedFiles.size>=3?"high":e.matchedFiles.size>=1?"medium":"low"}));return{changedFiles:l,affectedCapabilities:w,unmappedFiles:S,hasCapabilityMap:!!r}}export{A as detectDrift,k as getChangedFiles,x as loadAdoptionProfile,j as loadCapabilities,C as loadCapabilityMap};
+/**
+ * detect-drift.mjs
+ * Compares git-changed files to capability source maps and returns
+ * a list of capabilities that may need contract updates.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { execSync } from "node:child_process";
+
+/**
+ * Get files changed since the last commit (staged + unstaged),
+ * or optionally since the last N commits.
+ */
+export function getChangedFiles(cwd, opts = {}) {
+  const { sinceCommits = 1, includeStagedOnly = false } = opts;
+  const changed = new Set();
+
+  try {
+    // Staged + unstaged modifications vs HEAD
+    const unstaged = execSync("git diff --name-only HEAD", {
+      cwd, encoding: "utf8", timeout: 10_000,
+    });
+    for (const f of unstaged.split("\n").map(l => l.trim()).filter(Boolean)) {
+      changed.add(f);
+    }
+  } catch {}
+
+  try {
+    // Files changed in the last N commits
+    const committed = execSync(`git diff --name-only HEAD~${sinceCommits} HEAD`, {
+      cwd, encoding: "utf8", timeout: 10_000,
+    });
+    for (const f of committed.split("\n").map(l => l.trim()).filter(Boolean)) {
+      changed.add(f);
+    }
+  } catch {}
+
+  try {
+    // Untracked new files
+    const untracked = execSync("git ls-files --others --exclude-standard", {
+      cwd, encoding: "utf8", timeout: 10_000,
+    });
+    for (const f of untracked.split("\n").map(l => l.trim()).filter(Boolean)) {
+      changed.add(f);
+    }
+  } catch {}
+
+  return Array.from(changed).sort();
+}
+
+/**
+ * Load capability-map.json if it exists.
+ * Format: { "src/search/": ["SearchItems"], "src/auth/": ["Login"] }
+ */
+export function loadCapabilityMap(infernoDir) {
+  const mapPath = path.join(infernoDir, "capability-map.json");
+  if (!fs.existsSync(mapPath)) return null;
+  try { return JSON.parse(fs.readFileSync(mapPath, "utf8")); } catch { return null; }
+}
+
+/**
+ * Load adoption_profile.json (has sourceFiles per capability from --adopt).
+ */
+export function loadAdoptionProfile(infernoDir) {
+  const profilePath = path.join(infernoDir, "adoption_profile.json");
+  if (!fs.existsSync(profilePath)) return null;
+  try { return JSON.parse(fs.readFileSync(profilePath, "utf8")); } catch { return null; }
+}
+
+/**
+ * Load capabilities.json to get all registered capabilities.
+ */
+export function loadCapabilities(infernoDir) {
+  const capsPath = path.join(infernoDir, "capabilities.json");
+  if (!fs.existsSync(capsPath)) return [];
+  try {
+    const data = JSON.parse(fs.readFileSync(capsPath, "utf8"));
+    return data.capabilities || [];
+  } catch { return []; }
+}
+
+/**
+ * Main: detect which capabilities are affected by changed files.
+ *
+ * Returns:
+ * {
+ *   changedFiles: string[],
+ *   affectedCapabilities: { id, title, matchedFiles: string[], confidence: "high"|"medium"|"low" }[],
+ *   unmappedFiles: string[],           // changed files with no capability match
+ *   hasCapabilityMap: boolean,
+ * }
+ */
+export function detectDrift(cwd, opts = {}) {
+  const infernoDir = path.join(cwd, "inferno");
+  const changedFiles = getChangedFiles(cwd, opts);
+
+  if (!changedFiles.length) {
+    return { changedFiles: [], affectedCapabilities: [], unmappedFiles: [], hasCapabilityMap: false };
+  }
+
+  const capMap = loadCapabilityMap(infernoDir);
+  const profile = loadAdoptionProfile(infernoDir);
+  const capabilities = loadCapabilities(infernoDir);
+
+  const capHits = new Map(); // capId → { id, title, matchedFiles: Set }
+
+  const addHit = (cap, file) => {
+    if (!capHits.has(cap.id)) {
+      capHits.set(cap.id, { id: cap.id, title: cap.title || cap.id, matchedFiles: new Set() });
+    }
+    capHits.get(cap.id).matchedFiles.add(file);
+  };
+
+  const mappedFiles = new Set();
+
+  // ── Strategy 1: capability-map.json (explicit, highest confidence) ────────
+  if (capMap) {
+    for (const changedFile of changedFiles) {
+      for (const [prefix, capIds] of Object.entries(capMap)) {
+        if (changedFile.startsWith(prefix.replace(/\\/g, "/"))) {
+          for (const capId of capIds) {
+            const cap = capabilities.find(c => c.id === capId) || { id: capId, title: capId };
+            addHit(cap, changedFile);
+            mappedFiles.add(changedFile);
+          }
+        }
+      }
+    }
+  }
+
+  // ── Strategy 2: adoption_profile sourceFiles (from --adopt) ──────────────
+  // The profile doesn't directly store sourceFiles per cap (that's in capabilities.json via adopt).
+  // We use the capabilities sourceFiles stored during writeAdoptionBaseline.
+  // We re-read the raw capabilities with sourceFiles from the capabilities stored in inferno/.
+  const capsWithFiles = [];
+  if (profile) {
+    // Try to load a richer version from capabilities.json that includes sourceFiles
+    const capsPath = path.join(infernoDir, "capabilities.json");
+    try {
+      const raw = JSON.parse(fs.readFileSync(capsPath, "utf8"));
+      for (const c of raw.capabilities || []) {
+        if (c.sourceFiles && c.sourceFiles.length > 0) capsWithFiles.push(c);
+      }
+    } catch {}
+  }
+
+  if (capsWithFiles.length > 0) {
+    for (const cap of capsWithFiles) {
+      for (const srcFile of cap.sourceFiles || []) {
+        const normalized = srcFile.replace(/\\/g, "/");
+        for (const changedFile of changedFiles) {
+          const changedNorm = changedFile.replace(/\\/g, "/");
+          if (changedNorm === normalized || changedNorm.startsWith(path.dirname(normalized) + "/")) {
+            addHit(cap, changedFile);
+            mappedFiles.add(changedFile);
+          }
+        }
+      }
+    }
+  }
+
+  // ── Strategy 3: filename heuristics (fallback) ────────────────────────────
+  const HEURISTIC_KEYWORDS = [
+    { keywords: ["search"], capId: "SearchItems" },
+    { keywords: ["filter"], capId: "FilterItems" },
+    { keywords: ["auth", "login", "logout", "signin", "signup"], capId: "Authentication" },
+    { keywords: ["create", "add", "new"], capId: "CreateItem" },
+    { keywords: ["update", "edit"], capId: "UpdateItem" },
+    { keywords: ["delete", "remove"], capId: "DeleteItem" },
+    { keywords: ["read", "list", "view"], capId: "ReadItems" },
+    { keywords: ["due", "deadline", "date"], capId: "SetDueDate" },
+    { keywords: ["priority"], capId: "SetPriority" },
+    { keywords: ["complete", "done", "toggle"], capId: "ToggleComplete" },
+  ];
+
+  for (const changedFile of changedFiles) {
+    if (mappedFiles.has(changedFile)) continue;
+    const lower = changedFile.toLowerCase();
+    for (const rule of HEURISTIC_KEYWORDS) {
+      if (rule.keywords.some(kw => lower.includes(kw))) {
+        const cap = capabilities.find(c => c.id === rule.capId) || { id: rule.capId, title: rule.capId };
+        addHit(cap, changedFile);
+        mappedFiles.add(changedFile);
+        break;
+      }
+    }
+  }
+
+  const unmappedFiles = changedFiles.filter(f => !mappedFiles.has(f));
+
+  // Score confidence
+  const affectedCapabilities = Array.from(capHits.values()).map(hit => ({
+    id: hit.id,
+    title: hit.title,
+    matchedFiles: Array.from(hit.matchedFiles),
+    confidence: hit.matchedFiles.size >= 3 ? "high"
+              : hit.matchedFiles.size >= 1 ? "medium"
+              : "low",
+  }));
+
+  return {
+    changedFiles,
+    affectedCapabilities,
+    unmappedFiles,
+    hasCapabilityMap: !!capMap,
+  };
+}

package/dist/lib/learning/adapt.mjs

@@ -1,9 +1,104 @@
-import{readProfile as r,summarizeProfile as i}from"./profile.mjs";function o(t){let e;try{e=r(t)}catch{return""}const n=[];if(!(e.namingStyle!=="unknown"||e.preferredVerbs.length>0||e.stack.framework!=="unknown"))return"";if(n.push("## Developer profile (personalise your response to match these preferences)"),e.namingStyle!=="unknown"&&n.push(`- Capability naming style: **${e.namingStyle}** \u2014 use this for all new capability IDs`),e.preferredVerbs.length>0&&n.push(`- Preferred action verbs: ${e.preferredVerbs.slice(0,5).join(", ")} \u2014 prefer these when naming new capabilities`),e.stack.framework!=="unknown"&&n.push(`- Stack: ${e.stack.framework} / ${e.stack.language} (${e.stack.projectType})`),e.changelogVerbosity!=="unknown"){const s=e.changelogVerbosity==="brief"?"Keep changelog entries short (one line, action-focused)":"Write detailed changelog entries (include context and impact)";n.push(`- Changelog style: ${s}`)}if(e.featureClusters.length>0){const s=e.featureClusters[0];s.length>=2&&n.push(`- Common capability cluster: [${s.slice(0,4).join(", ")}] \u2014 if the task touches one of these, consider whether others need updating too`)}return e.sessionCount>=10&&n.push(`- Experienced user (${e.sessionCount} sessions) \u2014 skip basic explanations, be direct`),n.join(`
-`)}function c(t,e){const n=o(e);return n?t.includes("## Instructions")?t.replace("## Instructions",n+`
+/**
+ * lib/learning/adapt.mjs
+ * Uses developer-profile.json to personalise infernoflow prompts.
+ *
+ * Called by suggest/run before generating AI prompts so the AI
+ * receives instructions that match how this developer actually works.
+ */
 
-## Instructions`):t.includes("Respond with ONLY")?t.replace("Respond with ONLY",n+`
+import { readProfile, summarizeProfile } from "./profile.mjs";
 
----
-Respond with ONLY`):t+`
+/**
+ * Build a personalisation block to inject into any AI prompt.
+ * Returns an empty string if the profile doesn't have enough data yet.
+ *
+ * @param {string} infernoDir
+ * @returns {string}
+ */
+export function buildPersonalisationBlock(infernoDir) {
+  let profile;
+  try { profile = readProfile(infernoDir); } catch { return ""; }
 
-`+n:t}function u(t){try{const e=r(t);return i(e)||null}catch{return null}}export{o as buildPersonalisationBlock,c as personalisePrompt,u as profileStatusLine};
+  const lines = [];
+
+  // Only inject once there's real data (at least 1 session or seeded from adopt)
+  const hasData =
+    profile.namingStyle !== "unknown" ||
+    profile.preferredVerbs.length > 0 ||
+    profile.stack.framework !== "unknown";
+
+  if (!hasData) return "";
+
+  lines.push("## Developer profile (personalise your response to match these preferences)");
+
+  if (profile.namingStyle !== "unknown") {
+    lines.push(`- Capability naming style: **${profile.namingStyle}** — use this for all new capability IDs`);
+  }
+
+  if (profile.preferredVerbs.length > 0) {
+    lines.push(`- Preferred action verbs: ${profile.preferredVerbs.slice(0, 5).join(", ")} — prefer these when naming new capabilities`);
+  }
+
+  if (profile.stack.framework !== "unknown") {
+    lines.push(`- Stack: ${profile.stack.framework} / ${profile.stack.language} (${profile.stack.projectType})`);
+  }
+
+  if (profile.changelogVerbosity !== "unknown") {
+    const hint = profile.changelogVerbosity === "brief"
+      ? "Keep changelog entries short (one line, action-focused)"
+      : "Write detailed changelog entries (include context and impact)";
+    lines.push(`- Changelog style: ${hint}`);
+  }
+
+  if (profile.featureClusters.length > 0) {
+    const topCluster = profile.featureClusters[0];
+    if (topCluster.length >= 2) {
+      lines.push(`- Common capability cluster: [${topCluster.slice(0, 4).join(", ")}] — if the task touches one of these, consider whether others need updating too`);
+    }
+  }
+
+  if (profile.sessionCount >= 10) {
+    lines.push(`- Experienced user (${profile.sessionCount} sessions) — skip basic explanations, be direct`);
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Inject personalisation into an existing prompt string.
+ * Inserts the block just before the "## Instructions" section if present,
+ * otherwise appends it near the end.
+ *
+ * @param {string} prompt
+ * @param {string} infernoDir
+ * @returns {string}
+ */
+export function personalisePrompt(prompt, infernoDir) {
+  const block = buildPersonalisationBlock(infernoDir);
+  if (!block) return prompt;
+
+  // Insert before ## Instructions if that section exists
+  if (prompt.includes("## Instructions")) {
+    return prompt.replace("## Instructions", block + "\n\n## Instructions");
+  }
+
+  // Fallback: append before the closing JSON instructions
+  if (prompt.includes("Respond with ONLY")) {
+    return prompt.replace("Respond with ONLY", block + "\n\n---\nRespond with ONLY");
+  }
+
+  return prompt + "\n\n" + block;
+}
+
+/**
+ * Return a short status line for display in infernoflow status / context.
+ * e.g. "naming: PascalCase · verbs: Add, Update · stack: angular / ts · sessions: 12"
+ */
+export function profileStatusLine(infernoDir) {
+  try {
+    const profile = readProfile(infernoDir);
+    return summarizeProfile(profile) || null;
+  } catch {
+    return null;
+  }
+}

package/dist/lib/learning/observe.mjs

@@ -1 +1,119 @@
-import"node:path";import{readProfile as c,writeProfile as i,recordCommandUse as l,recordSessionCommand as f,detectNamingStyle as d,detectPreferredVerbs as a,recordCapabilityCluster as m}from"./profile.mjs";const g=1800*1e3;function S(n,t,e={}){try{const o=c(n);l(o,t);const r=Date.now(),s=o._lastCommandTs||0;r-s>g&&(o.sessionCount=(o.sessionCount||0)+1),o._lastCommandTs=r,f(o,t,e),i(n,o)}catch{}}function b(n,t){if(!(!t||t.length===0))try{const e=c(n),o=d(t);o!=="unknown"&&(e.sessionCount>=3||e.namingStyle==="unknown")&&(e.namingStyle=o);const r=a(t);if(r.length>0){const s=[...new Set([...e.preferredVerbs,...r])];e.preferredVerbs=s.slice(0,8)}t.length>=2&&m(e,t),i(n,e)}catch{}}function C(n,t){if(t)try{const e=c(n),r=String(t).trim().split(/\s+/).length>=15?"detailed":"brief";(e.changelogVerbosity==="unknown"||e.sessionCount>=5)&&(e.changelogVerbosity=r),i(n,e)}catch{}}export{b as observeCapabilitiesAdded,C as observeChangelogEntry,S as observeCommandStart};
+/**
+ * lib/learning/observe.mjs
+ * Silent behavior recorder — called at the start of every CLI command.
+ *
+ * Records:
+ *  - Which command was run (commandUsage counts)
+ *  - When it was run (session detection)
+ *  - New capabilities introduced via suggest/run (updates naming style + verbs + clusters)
+ *
+ * Never throws — all observation is best-effort so it never breaks the real command.
+ */
+
+import * as path from "node:path";
+import {
+  readProfile,
+  writeProfile,
+  recordCommandUse,
+  recordSessionCommand,
+  detectNamingStyle,
+  detectPreferredVerbs,
+  recordCapabilityCluster,
+} from "./profile.mjs";
+
+const SESSION_GAP_MS = 30 * 60 * 1000; // 30 minutes = new session
+
+/**
+ * Call this at the very start of every command handler.
+ *
+ * @param {string} infernoDir  — path to the inferno/ directory
+ * @param {string} command     — the CLI command name (e.g. "suggest", "run", "check")
+ * @param {object} [extras]    — optional: { task: string } for suggest/implement/run
+ */
+export function observeCommandStart(infernoDir, command, extras = {}) {
+  try {
+    const profile = readProfile(infernoDir);
+
+    // Record command usage
+    recordCommandUse(profile, command);
+
+    // Detect new session (gap > 30 min since last command)
+    const now = Date.now();
+    const lastTs = profile._lastCommandTs || 0;
+    if (now - lastTs > SESSION_GAP_MS) {
+      profile.sessionCount = (profile.sessionCount || 0) + 1;
+    }
+    profile._lastCommandTs = now;
+
+    // Sprint 5: record rich session event
+    recordSessionCommand(profile, command, extras);
+
+    writeProfile(infernoDir, profile);
+  } catch {
+    // Silent — never break the real command
+  }
+}
+
+/**
+ * Call this after a suggest/run/apply that added new capabilities.
+ * Updates naming style, preferred verbs, and feature clusters in the profile.
+ *
+ * @param {string}   infernoDir      — path to inferno/
+ * @param {string[]} newCapabilityIds — capability IDs that were just added
+ */
+export function observeCapabilitiesAdded(infernoDir, newCapabilityIds) {
+  if (!newCapabilityIds || newCapabilityIds.length === 0) return;
+  try {
+    const profile = readProfile(infernoDir);
+
+    // Update naming style (weighted: new observations vs existing preference)
+    const detectedStyle = detectNamingStyle(newCapabilityIds);
+    if (detectedStyle !== "unknown") {
+      // If we have enough sessions to be confident, lock it in
+      if (profile.sessionCount >= 3 || profile.namingStyle === "unknown") {
+        profile.namingStyle = detectedStyle;
+      }
+    }
+
+    // Update preferred verbs
+    const newVerbs = detectPreferredVerbs(newCapabilityIds);
+    if (newVerbs.length > 0) {
+      const combined = [...new Set([...profile.preferredVerbs, ...newVerbs])];
+      profile.preferredVerbs = combined.slice(0, 8); // keep top 8
+    }
+
+    // Record as a feature cluster if multiple capabilities were added together
+    if (newCapabilityIds.length >= 2) {
+      recordCapabilityCluster(profile, newCapabilityIds);
+    }
+
+    writeProfile(infernoDir, profile);
+  } catch {
+    // Silent
+  }
+}
+
+/**
+ * Record changelog verbosity from a changelog entry string.
+ * Helps infernoflow learn whether this developer writes brief or detailed changelogs.
+ */
+export function observeChangelogEntry(infernoDir, entry) {
+  if (!entry) return;
+  try {
+    const profile = readProfile(infernoDir);
+    const wordCount = String(entry).trim().split(/\s+/).length;
+    const verbosity = wordCount >= 15 ? "detailed" : "brief";
+
+    // Use running average: weight new observation against history
+    if (profile.changelogVerbosity === "unknown") {
+      profile.changelogVerbosity = verbosity;
+    } else if (profile.sessionCount >= 5) {
+      // After enough sessions, trust the pattern
+      profile.changelogVerbosity = verbosity;
+    }
+
+    writeProfile(infernoDir, profile);
+  } catch {
+    // Silent
+  }
+}