infernoflow 0.14.0 → 0.17.0

package/dist/bin/infernoflow.mjs

@@ -35,6 +35,11 @@ const COMMAND_DESCRIPTIONS = {
   "pr-comment": "Post capability drift analysis as a GitHub PR comment (works in CI automatically)",
   dashboard: "Launch local web dashboard on localhost:7337 — live contract health, capabilities, agents",
   "team-sync": "Sync capability contract across a team via a shared git branch (push | pull | status | init)",
+  onboard: "Interactive onboarding wizard for new developers — explains infernoflow in 5 minutes",
+  cloud:   "Sync capability contracts via infernoflow cloud (init | push | pull | status | dashboard)",
+  share:   "Generate a public read-only HTML snapshot of your capability contract",
+  watch:   "Watch source files and run suggest automatically on save",
+  ci:      "CI-native check: GitHub Actions annotations, GitLab code quality, exit codes",
 };
 
 const COMMAND_HANDLERS = {
@@ -63,6 +68,11 @@ const COMMAND_HANDLERS = {
   "pr-comment": async (args) => (await import("../lib/commands/prComment.mjs")).prCommentCommand(args),
   dashboard: async (args) => (await import("../lib/commands/dashboard.mjs")).dashboardCommand(args),
   "team-sync": async (args) => (await import("../lib/commands/teamSync.mjs")).teamSyncCommand(args),
+  onboard: async (args) => (await import("../lib/commands/onboard.mjs")).onboardCommand(args),
+  cloud:   async (args) => (await import("../lib/commands/cloud.mjs")).cloudCommand(args),
+  share:   async (args) => (await import("../lib/commands/share.mjs")).shareCommand(args),
+  watch:   async (args) => (await import("../lib/commands/watch.mjs")).watchCommand(args),
+  ci:      async (args) => (await import("../lib/commands/ci.mjs")).ciCommand(args),
 };
 
 function formatCommandsHelp() {
@@ -92,7 +102,9 @@ ${formatCommandsHelp()}
     update                    Draft ## Unreleased from commits (default sub-command)
     show                      Print the current ## Unreleased block
     list                      List commits since last tag
+    ai                        Generate human-readable changelog with AI (Anthropic or Ollama)
     --ref <tag|commit>        Use a specific ref instead of last tag
+    --version <x.y.z>         Version label for the AI-generated entry
     --dry-run                 Print what would be written without modifying file
     --append                  Append to existing ## Unreleased instead of replacing
     --json                    Machine-readable output
@@ -181,6 +193,38 @@ ${formatCommandsHelp()}
     --dry-run             Print the comment without posting it
     --json                Machine-readable output
 
+  ${bold("cloud sub-commands:")}
+    init                      Generate a project token and configure cloud sync
+    push                      Upload local capability contract to cloud
+    pull                      Download latest contract from cloud (conflict detection)
+    status                    Compare local vs cloud (hashes, capability counts)
+    dashboard                 Print hosted dashboard URL and open in browser
+
+  ${bold("cloud options:")}
+    --token <tok>             Override token (or set INFERNOFLOW_TOKEN env var)
+    --endpoint <url>          Override default endpoint (https://cloud.infernoflow.dev)
+    --force, -f               Overwrite on init; overwrite local on conflicted pull
+    --dry-run                 Print what would happen without sending
+    --json                    Machine-readable output
+
+  ${bold("share options:")}
+    --upload                  Upload to dpaste.com and print a public URL
+    --open                    Open the snapshot in your browser immediately
+    --copy                    Copy HTML to clipboard
+    --out <path>              Custom output path (default: inferno/share.html)
+    --json                    Machine-readable: { ok, file, url }
+
+  ${bold("watch options:")}
+    [dirs...]                 Directories to watch (default: src/, lib/, app/)
+    --interval <secs>         Debounce interval in seconds (default: 3)
+    --dry-run                 Print what would run without executing
+    --silent                  No output (for git hook use)
+
+  ${bold("ci options:")}
+    --platform <name>         github | gitlab | bitbucket | generic (auto-detected)
+    --fail-on <level>         error | warning (default: error)
+    --json                    Machine-readable result + exit code
+
   ${bold("Machine output:")}
     ${gray("status --json")}
     ${gray("check --json")}

package/dist/lib/commands/changelog.mjs

@@ -303,6 +303,248 @@ async function subcmdUpdate(cwd, changelogPath, opts) {
   console.log(`  Run ${cyan("infernoflow publish")} when ready to cut the release\n`);
 }
 
+// ── AI changelog writer ───────────────────────────────────────────────────────
+
+function parseCaps(jsonText) {
+  if (!jsonText) return [];
+  try {
+    const obj = JSON.parse(jsonText);
+    const raw = obj.capabilities || [];
+    return raw.map(c => typeof c === "string" ? { id: c, title: c } : c);
+  } catch { return []; }
+}
+
+function loadCapsFromDisk(infernoDir) {
+  for (const name of ["capabilities.json", "contract.json"]) {
+    const p = path.join(infernoDir, name);
+    if (fs.existsSync(p)) return parseCaps(fs.readFileSync(p, "utf8"));
+  }
+  return [];
+}
+
+function loadCapsAtRef(ref, cwd) {
+  const { execSync: _exec } = await import ? null : null; // handled below
+  try {
+    const { execSync: ex } = await import("node:child_process");
+    for (const name of ["capabilities.json", "contract.json"]) {
+      try {
+        const content = ex(`git show "${ref}:inferno/${name}"`, {
+          cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"]
+        }).trim();
+        if (content) return parseCaps(content);
+      } catch {}
+    }
+  } catch {}
+  return [];
+}
+
+function diffCapsSimple(before, after) {
+  const beforeMap = new Map(before.map(c => [c.id, c]));
+  const afterMap  = new Map(after.map(c  => [c.id, c]));
+  return {
+    added:   after.filter(c  => !beforeMap.has(c.id)),
+    removed: before.filter(c => !afterMap.has(c.id)),
+    changed: after.filter(c  => {
+      const old = beforeMap.get(c.id);
+      return old && old.title !== c.title;
+    }),
+  };
+}
+
+function buildAiPrompt(commits, diff, ref, version) {
+  const lines = [];
+  lines.push(`You are writing a changelog entry for a software release.`);
+  lines.push(`Write it in a friendly, clear, developer-facing tone.`);
+  lines.push(`Use Markdown. Start with ## ${version || "Unreleased"}`);
+  lines.push(`Include sections: ### Added, ### Fixed, ### Changed, ### Removed (only if non-empty).`);
+  lines.push(`Be concise — one line per item. Do not include commit hashes.`);
+  lines.push(`Do not invent features that are not listed below.`);
+  lines.push(``);
+  lines.push(`## Capability changes since ${ref || "last release"}:`);
+  if (diff.added.length)   lines.push(`Added: ${diff.added.map(c => c.title || c.id).join(", ")}`);
+  if (diff.removed.length) lines.push(`Removed: ${diff.removed.map(c => c.title || c.id).join(", ")}`);
+  if (diff.changed.length) lines.push(`Changed: ${diff.changed.map(c => c.title || c.id).join(", ")}`);
+  if (!diff.added.length && !diff.removed.length && !diff.changed.length) lines.push(`(no capability changes)`);
+  lines.push(``);
+  lines.push(`## Git commits since ${ref || "last release"}:`);
+  for (const c of commits.slice(0, 40)) lines.push(`- ${c.subject}`);
+  lines.push(``);
+  lines.push(`Write the changelog entry now:`);
+  return lines.join("\n");
+}
+
+function buildStructuredFallback(commits, diff, version) {
+  // High-quality template fallback when no AI provider is available
+  const sections = groupCommits(commits);
+
+  // Merge capability changes into sections
+  for (const c of diff.added)   sections.Added.unshift(`${c.title || c.id} capability`);
+  for (const c of diff.removed) sections.Removed.unshift(`${c.title || c.id} capability`);
+  for (const c of diff.changed) sections.Changed.unshift(`Updated ${c.title || c.id} capability`);
+
+  // Deduplicate
+  for (const key of Object.keys(sections)) sections[key] = [...new Set(sections[key])];
+
+  const tag = version || "Unreleased";
+  const date = new Date().toISOString().slice(0, 10);
+  const lines = [`## ${tag} — ${date}`, ""];
+
+  const ORDER = ["Breaking", "Added", "Fixed", "Changed", "Removed"];
+  for (const heading of ORDER) {
+    const items = sections[heading];
+    if (!items?.length) continue;
+    lines.push(`### ${heading}`);
+    for (const item of items) lines.push(`- ${item}`);
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+async function callLocalAi(prompt) {
+  // Try Ollama (localhost:11434) — most common local AI setup
+  try {
+    const { default: http } = await import("node:http");
+    return new Promise((resolve, reject) => {
+      const body = JSON.stringify({ model: "llama3", prompt, stream: false });
+      const req = http.request({
+        hostname: "localhost", port: 11434,
+        path: "/api/generate", method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) },
+      }, (res) => {
+        let raw = "";
+        res.on("data", d => raw += d);
+        res.on("end", () => {
+          try { resolve(JSON.parse(raw).response || null); } catch { resolve(null); }
+        });
+      });
+      req.setTimeout(30_000, () => { req.destroy(); reject(new Error("timeout")); });
+      req.on("error", reject);
+      req.write(body);
+      req.end();
+    });
+  } catch { return null; }
+}
+
+async function callAnthropicAi(prompt, apiKey) {
+  const { default: https } = await import("node:https");
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({
+      model: "claude-haiku-4-5-20251001",
+      max_tokens: 1024,
+      messages: [{ role: "user", content: prompt }],
+    });
+    const req = https.request({
+      hostname: "api.anthropic.com",
+      path: "/v1/messages", method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(body),
+      },
+    }, (res) => {
+      let raw = "";
+      res.on("data", d => raw += d);
+      res.on("end", () => {
+        try {
+          const data = JSON.parse(raw);
+          resolve(data.content?.[0]?.text || null);
+        } catch { resolve(null); }
+      });
+    });
+    req.setTimeout(30_000, () => { req.destroy(); reject(new Error("timeout")); });
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+async function subcmdAi(cwd, changelogPath, opts) {
+  const { ref, dryRun, asJson, version } = opts;
+  const infernoDir = path.join(cwd, "inferno");
+
+  const tag     = ref || lastTag(cwd);
+  const commits = commitsSince(tag, cwd);
+
+  // Load capability diff
+  const currentCaps = fs.existsSync(infernoDir) ? loadCapsFromDisk(infernoDir) : [];
+  const prevCaps    = tag ? (() => {
+    try {
+      const ex = require("child_process").execSync;
+      for (const name of ["capabilities.json", "contract.json"]) {
+        try {
+          const c = ex(`git show "${tag}:inferno/${name}"`, { cwd, encoding: "utf8", stdio: ["ignore","pipe","pipe"] }).trim();
+          if (c) return parseCaps(c);
+        } catch {}
+      }
+      return [];
+    } catch { return []; }
+  })() : [];
+
+  const diff = diffCapsSimple(prevCaps, currentCaps);
+
+  if (!asJson) {
+    info(`Generating AI changelog since ${bold(tag || "beginning")}...`);
+    info(`${commits.length} commits · ${diff.added.length} added · ${diff.removed.length} removed · ${diff.changed.length} changed`);
+    console.log();
+  }
+
+  const prompt = buildAiPrompt(commits, diff, tag, version);
+  let aiText = null;
+  let provider = "template";
+
+  // Try AI providers in order: Anthropic API → Ollama → structured template
+  const anthropicKey = process.env.ANTHROPIC_API_KEY;
+  if (anthropicKey) {
+    try {
+      aiText = await callAnthropicAi(prompt, anthropicKey);
+      if (aiText) provider = "anthropic";
+    } catch {}
+  }
+
+  if (!aiText) {
+    try {
+      aiText = await callLocalAi(prompt);
+      if (aiText) provider = "ollama";
+    } catch {}
+  }
+
+  // Fallback: structured template
+  if (!aiText) {
+    aiText = buildStructuredFallback(commits, diff, version);
+    provider = "template";
+  }
+
+  if (asJson) {
+    console.log(JSON.stringify({ ok: true, provider, ref: tag, commits: commits.length, markdown: aiText }));
+    return;
+  }
+
+  console.log(gray("  ─── Generated changelog ──────────────────────────────"));
+  aiText.split("\n").forEach(l => console.log("  " + l));
+  console.log(gray("  ──────────────────────────────────────────────────────"));
+  console.log();
+  info(`Generated via: ${bold(provider)}`);
+
+  if (dryRun) {
+    warn("Dry run — CHANGELOG.md not modified");
+    console.log();
+    return;
+  }
+
+  // Write to CHANGELOG.md
+  let text = fs.existsSync(changelogPath) ? fs.readFileSync(changelogPath, "utf8") : "# Changelog\n\n";
+  const updated = injectUnreleased(text, aiText);
+  fs.writeFileSync(changelogPath, updated);
+
+  ok(`CHANGELOG.md updated with AI-generated entry`);
+  if (provider === "template") {
+    info(`Tip: set ANTHROPIC_API_KEY for richer AI-written changelogs`);
+  }
+  console.log();
+}
+
 // ── main ─────────────────────────────────────────────────────────────────────
 
 export async function changelogCommand(rawArgs) {
@@ -311,12 +553,14 @@ export async function changelogCommand(rawArgs) {
   // Sub-command: first non-flag arg
   const sub = args.find(a => !a.startsWith("-")) || "update";
 
-  const dryRun = args.includes("--dry-run");
-  const append = args.includes("--append");
-  const asJson = args.includes("--json");
+  const dryRun  = args.includes("--dry-run");
+  const append  = args.includes("--append");
+  const asJson  = args.includes("--json");
 
-  const refIdx = args.indexOf("--ref");
-  const ref    = refIdx !== -1 ? args[refIdx + 1] : null;
+  const refIdx     = args.indexOf("--ref");
+  const versionIdx = args.indexOf("--version");
+  const ref     = refIdx     !== -1 ? args[refIdx + 1]     : null;
+  const version = versionIdx !== -1 ? args[versionIdx + 1] : null;
 
   const cwd           = process.cwd();
   const changelogPath = path.join(cwd, "CHANGELOG.md");
@@ -338,6 +582,11 @@ export async function changelogCommand(rawArgs) {
     return;
   }
 
-  fail(`Unknown sub-command: ${sub}`, "Use: update | show | list");
+  if (sub === "ai") {
+    await subcmdAi(cwd, changelogPath, { ref, dryRun, asJson, version });
+    return;
+  }
+
+  fail(`Unknown sub-command: ${sub}`, "Use: update | show | list | ai");
   process.exit(1);
 }

package/dist/lib/commands/ci.mjs

@@ -0,0 +1,207 @@
+/**
+ * infernoflow ci
+ *
+ * Auto-detect the CI environment and output structured annotations that
+ * integrate natively with each platform's UI.
+ *
+ * Supported platforms:
+ *   GitHub Actions   → ::error:: / ::warning:: / step summary (GITHUB_STEP_SUMMARY)
+ *   GitLab CI        → gl-code-quality.json artifact
+ *   Bitbucket        → annotations API via curl
+ *   Generic          → exit code + JSON output (for any CI)
+ *
+ * Usage:
+ *   infernoflow ci                     Auto-detect platform, run check + diff
+ *   infernoflow ci --platform github   Force a platform
+ *   infernoflow ci --fail-on warning   Fail on warning or higher (default: error)
+ *   infernoflow ci --json              Machine-readable result
+ *
+ * Exits 0 on success, 1 on error/warning (based on --fail-on).
+ */
+
+import * as fs   from "node:fs";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+import { header, ok, warn, info, done, bold, cyan, gray, green, red, yellow } from "../ui/output.mjs";
+
+// ── Platform detection ────────────────────────────────────────────────────────
+
+function detectPlatform() {
+  if (process.env.GITHUB_ACTIONS === "true")       return "github";
+  if (process.env.GITLAB_CI === "true")            return "gitlab";
+  if (process.env.BITBUCKET_BUILD_NUMBER)          return "bitbucket";
+  if (process.env.CIRCLECI === "true")             return "circleci";
+  if (process.env.JENKINS_URL)                     return "jenkins";
+  if (process.env.CI === "true")                   return "generic";
+  return "local";
+}
+
+// ── CLI runner ────────────────────────────────────────────────────────────────
+
+function runJson(command, cwd) {
+  try {
+    const [bin, ...args] = command.split(" ");
+    const result = spawnSync(process.execPath, [
+      path.join(path.dirname(path.dirname(new URL(import.meta.url).pathname)), "..", "bin", "infernoflow.mjs"),
+      ...command.split(" ").slice(1)
+    ], { cwd, encoding: "utf8", timeout: 30_000 });
+    const out = result.stdout?.trim();
+    if (out) return JSON.parse(out);
+  } catch {}
+  return null;
+}
+
+function runCli(args, cwd) {
+  try {
+    const result = spawnSync(process.execPath, [
+      path.join(path.dirname(path.dirname(new URL(import.meta.url).pathname)), "..", "bin", "infernoflow.mjs"),
+      ...args
+    ], { cwd, encoding: "utf8", timeout: 30_000 });
+    return result.stdout?.trim() || "";
+  } catch { return ""; }
+}
+
+// ── GitHub Actions output ─────────────────────────────────────────────────────
+
+function emitGithub(checkResult, diffResult, failOn) {
+  const status = checkResult?.status || "unknown";
+  const issues = checkResult?.issues || [];
+  const caps   = checkResult?.capabilities || 0;
+  const added  = diffResult?.added?.length || 0;
+  const removed = diffResult?.removed?.length || 0;
+  const changed = diffResult?.changed?.length || 0;
+
+  // GitHub workflow commands
+  if (status === "error") {
+    issues.filter(i => i.severity === "error").forEach(i => {
+      console.log(`::error::infernoflow: ${i.message}`);
+    });
+  } else if (status === "warning") {
+    issues.filter(i => i.severity === "warning").forEach(i => {
+      console.log(`::warning::infernoflow: ${i.message}`);
+    });
+  }
+
+  if (added > 0)   console.log(`::notice::infernoflow: ${added} new capability${added !== 1 ? "ies" : "y"} added`);
+  if (removed > 0) console.log(`::warning::infernoflow: ${removed} capability${removed !== 1 ? "ies" : "y"} removed`);
+
+  // Step summary
+  const summaryPath = process.env.GITHUB_STEP_SUMMARY;
+  if (summaryPath) {
+    const statusIcon = status === "ok" ? "✅" : status === "warning" ? "⚠️" : "❌";
+    const lines = [
+      `## 🔥 infernoflow CI report`,
+      "",
+      `${statusIcon} **Status:** ${status.toUpperCase()}  ·  **Capabilities:** ${caps}`,
+      "",
+    ];
+    if (added || removed || changed) {
+      lines.push("### Capability changes");
+      if (added)   lines.push(`- ✅ **${added}** added`);
+      if (removed) lines.push(`- ❌ **${removed}** removed`);
+      if (changed) lines.push(`- 📝 **${changed}** changed`);
+      lines.push("");
+    }
+    if (issues.length) {
+      lines.push("### Issues");
+      issues.forEach(i => lines.push(`- **${i.severity?.toUpperCase() || "INFO"}**: ${i.message}`));
+      lines.push("");
+    }
+    lines.push("---");
+    lines.push("*Generated by [infernoflow](https://github.com/ronmiz/infernoflow)*");
+    try { fs.appendFileSync(summaryPath, lines.join("\n") + "\n"); } catch {}
+  }
+}
+
+// ── GitLab code quality report ────────────────────────────────────────────────
+
+function emitGitlab(checkResult, cwd) {
+  const issues = checkResult?.issues || [];
+  const report = issues.map((issue, i) => ({
+    description:      issue.message || "infernoflow issue",
+    fingerprint:      Buffer.from(`infernoflow-${i}-${issue.message}`).toString("hex").slice(0, 40),
+    severity:         issue.severity === "error" ? "critical" : "minor",
+    location: {
+      path:       "inferno/contract.json",
+      lines:      { begin: 1 },
+    },
+  }));
+  const reportPath = path.join(cwd, "gl-code-quality-report.json");
+  fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+  console.log(`infernoflow: GitLab code quality report written → gl-code-quality-report.json`);
+}
+
+// ── Generic CI output ─────────────────────────────────────────────────────────
+
+function emitGeneric(checkResult, diffResult, platform) {
+  const status = checkResult?.status || "unknown";
+  const caps   = checkResult?.capabilities || 0;
+  const added  = diffResult?.added?.length || 0;
+  const removed = diffResult?.removed?.length || 0;
+
+  console.log(`[infernoflow] platform=${platform} status=${status} capabilities=${caps} added=${added} removed=${removed}`);
+  if (checkResult?.issues?.length) {
+    checkResult.issues.forEach(i => {
+      console.log(`[infernoflow] ${(i.severity || "info").toUpperCase()}: ${i.message}`);
+    });
+  }
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+
+export async function ciCommand(rawArgs) {
+  const args        = rawArgs.slice(1);
+  const jsonMode    = args.includes("--json");
+  const platformArg = args.includes("--platform") ? args[args.indexOf("--platform") + 1] : null;
+  const failOn      = args.includes("--fail-on") ? args[args.indexOf("--fail-on") + 1] : "error";
+  const cwd         = process.cwd();
+  const infernoDir  = path.join(cwd, "inferno");
+
+  if (!fs.existsSync(infernoDir)) {
+    if (jsonMode) { console.log(JSON.stringify({ ok: false, error: "inferno/ not found" })); }
+    else { console.log("[infernoflow] inferno/ not found — skipping CI check"); }
+    process.exit(0); // Don't block CI if infernoflow isn't set up
+  }
+
+  const platform = platformArg || detectPlatform();
+
+  if (!jsonMode) {
+    console.log(`[infernoflow] running CI check (platform: ${platform})`);
+  }
+
+  // Run check + diff
+  const checkResult = runJson("check --json", cwd);
+  const diffResult  = runJson("diff --json", cwd);
+  const status      = checkResult?.status || "unknown";
+
+  // Platform-specific output
+  switch (platform) {
+    case "github":
+      emitGithub(checkResult, diffResult, failOn);
+      break;
+    case "gitlab":
+      emitGitlab(checkResult, cwd);
+      emitGeneric(checkResult, diffResult, platform);
+      break;
+    default:
+      emitGeneric(checkResult, diffResult, platform);
+  }
+
+  if (jsonMode) {
+    console.log(JSON.stringify({
+      ok:       status === "ok" || status === "warning",
+      platform,
+      status,
+      capabilities: checkResult?.capabilities || 0,
+      issues:   checkResult?.issues || [],
+      diff:     { added: diffResult?.added || [], removed: diffResult?.removed || [], changed: diffResult?.changed || [] },
+    }));
+  }
+
+  // Exit code
+  const shouldFail = failOn === "warning"
+    ? (status === "error" || status === "warning")
+    : (status === "error");
+
+  process.exit(shouldFail ? 1 : 0);
+}