arkaos 4.34.0 → 4.35.0

package/installer/adapters/opencode.js

@@ -0,0 +1,118 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { listBundleFiles, readBundleFile } from "../harness-bundle.js";
+
+/**
+ * OpenCode adapter (Foundation PR-6). Deploys the generated harness
+ * bundle onto OpenCode's native surfaces (opencode.ai/docs):
+ *
+ *   AGENTS.md      instructions contract (same body as codex)
+ *   agents/*.md    curated agent cut (C-suite + squad leads)
+ *   commands/*.md  one /arka-<dept> router command per department
+ *   opencode.json  arka-tools MCP — merged NON-destructively
+ *
+ * Merge contract: user keys ALWAYS win. An existing `$schema`, any
+ * user-defined `mcp` server, or a user-modified `arka-tools` entry is
+ * never overwritten; a corrupt opencode.json is never clobbered (we
+ * skip with a warning instead — config-seed.js posture).
+ */
+
+/**
+ * Pure, exported for tests. Returns:
+ *   { config, changed }  merged object + whether anything was added
+ *   null                 leave the file alone (corrupt input)
+ */
+export function mergeOpencodeConfig(existingText, fragmentText) {
+  let fragment;
+  try {
+    fragment = JSON.parse(fragmentText);
+  } catch {
+    return null;
+  }
+  let existing = {};
+  const trimmed = (existingText ?? "").trim();
+  if (trimmed !== "") {
+    try {
+      existing = JSON.parse(trimmed);
+    } catch {
+      return null; // corrupt user config — never clobber
+    }
+    if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+      return null;
+    }
+  }
+  const merged = { ...existing };
+  let changed = false;
+  if (!merged.$schema && fragment.$schema) {
+    merged.$schema = fragment.$schema;
+    changed = true;
+  }
+  const userMcp =
+    merged.mcp && typeof merged.mcp === "object" && !Array.isArray(merged.mcp)
+      ? merged.mcp
+      : {};
+  const mcp = { ...userMcp };
+  for (const [name, server] of Object.entries(fragment.mcp || {})) {
+    if (!(name in mcp)) {
+      mcp[name] = server;
+      changed = true;
+    }
+  }
+  if (changed && Object.keys(mcp).length > 0) merged.mcp = mcp;
+  return { config: merged, changed };
+}
+
+export default {
+  configureHooks(config) {
+    // OpenCode has no shell-hook chain; "configure" means deploying the
+    // instruction/agent/command surfaces + the MCP config merge.
+    const agentsMd = readBundleFile("opencode", "AGENTS.md");
+    if (!agentsMd) {
+      console.warn(
+        "         OpenCode bundle missing (harness/opencode/) — " +
+          "run scripts/harness_gen.py; skipping."
+      );
+      return;
+    }
+    mkdirSync(config.configDir, { recursive: true });
+    writeFileSync(join(config.configDir, "AGENTS.md"), agentsMd);
+
+    let deployed = 0;
+    for (const sub of ["agents", "commands"]) {
+      const names = listBundleFiles("opencode", sub);
+      if (names.length === 0) continue;
+      mkdirSync(join(config.configDir, sub), { recursive: true });
+      for (const name of names) {
+        const content = readBundleFile("opencode", `${sub}/${name}`);
+        if (content === null) continue;
+        writeFileSync(join(config.configDir, sub, name), content);
+        deployed += 1;
+      }
+    }
+
+    const fragment = readBundleFile("opencode", "opencode.json");
+    if (fragment) {
+      const existingText = existsSync(config.settingsFile)
+        ? readFileSync(config.settingsFile, "utf-8")
+        : "";
+      const result = mergeOpencodeConfig(existingText, fragment);
+      if (result === null) {
+        console.warn(
+          "         opencode.json unreadable — left untouched " +
+            "(the merge is never destructive)."
+        );
+      } else if (result.changed) {
+        writeFileSync(
+          config.settingsFile,
+          JSON.stringify(result.config, null, 2) + "\n"
+        );
+        console.log(
+          "         opencode.json updated (arka-tools MCP registered, user keys preserved)."
+        );
+      }
+    }
+    console.log(
+      `         OpenCode configured (AGENTS.md + ${deployed} agent/command files).`
+    );
+  },
+};

package/installer/cli.js

@@ -21,6 +21,10 @@ const { values, positionals } = parseArgs({
     force: { type: "boolean", short: "f" },
     "no-system": { type: "boolean" },
     "with-ollama": { type: "boolean" },
+    // Foundation PR-3 — `npx arkaos install --profile <essential|complete|local-ai>`.
+    // Declared so it lands in `values.profile` instead of a free
+    // positional under strict:false (the documented --fix lesson).
+    profile: { type: "string" },
     // PR3.5 v3.74.1 — declared so `npx arkaos doctor --fix` lands in
     // `values.fix` rather than as a free positional under strict:false.
     // Eliminates the dead-branch fallback flagged by Marta in PR2's QG.
@@ -57,6 +61,7 @@ ArkaOS v${VERSION} — The Operating System for AI Agent Teams
 Usage:
   npx arkaos install          Install ArkaOS in current environment
   npx arkaos install --runtime <runtime>  Install for specific runtime
+  npx arkaos install --profile <profile>  Pick the install profile non-interactively
   npx arkaos init             Initialize project config (.arkaos.json)
   npx arkaos update           Update to latest version
   npx arkaos migrate          Migrate from v1 to v2
@@ -64,6 +69,7 @@ Usage:
   npx arkaos dashboard        Start monitoring dashboard
   npx arkaos autostart <enable|disable|status>  Start dashboard on boot
   npx arkaos autoupdate <enable|disable|status|run>  Keep ArkaOS updated automatically (daily check + notification)
+  npx arkaos menubar <enable|disable|status>  Menu bar launcher (macOS — ▲ quick actions)
   npx arkaos keys             Manage API keys (OpenAI, fal.ai, etc.)
   npx arkaos models           Model Fabric: which model runs each role
   npx arkaos models set <role> <provider>/<model>  Re-route a role
@@ -77,6 +83,9 @@ Options:
   -r, --runtime <name>   Target runtime: claude-code, codex, gemini, cursor
   -p, --path <dir>       Installation directory (default: auto-detect)
   -f, --force            Force reinstall, overwriting existing files
+  --profile <name>       Install profile: essential (venv, hooks, skills,
+                         dashboard, MCPs), complete (+ litellm[proxy], ffmpeg),
+                         local-ai (+ Ollama, local execution model)
   -v, --version          Show version
   -h, --help             Show this help
 
@@ -100,7 +109,20 @@ Examples:
 
 async function main() {
   switch (command) {
-    case "install":
+    case "install": {
+      // Validate --profile up front (before runtime detection) so a
+      // typo fails fast instead of silently falling back to the wizard.
+      let profileFlag;
+      if (values.profile !== undefined) {
+        const { normalizeProfileFlag, INSTALL_PROFILES } = await import("./profile.js");
+        profileFlag = normalizeProfileFlag(values.profile);
+        if (!profileFlag) {
+          console.error(
+            `Invalid --profile "${values.profile}". Valid values: ${INSTALL_PROFILES.join(", ")}`
+          );
+          process.exit(1);
+        }
+      }
       const runtime = values.runtime || await detectRuntime();
       await install({
         runtime,
@@ -108,8 +130,10 @@ async function main() {
         force: values.force,
         skipSystem: values["no-system"],
         withOllama: values["with-ollama"],
+        profileFlag,
       });
       break;
+    }
 
     case "init": {
       const { init } = await import("./init.js");
@@ -141,6 +165,12 @@ async function main() {
       break;
     }
 
+    case "menubar": {
+      const { menubar } = await import("./menubar.js");
+      await menubar(positionals.slice(1));
+      break;
+    }
+
     case "uninstall":
       const { uninstall } = await import("./uninstall.js");
       await uninstall();

package/installer/detect-runtime.js

@@ -69,6 +69,24 @@ const RUNTIMES = [
     skillsDir: () => join(homedir(), ".cursor", "skills"),
     settingsFile: () => join(homedir(), ".cursor", "settings.json"),
   },
+  {
+    // Foundation PR-6 — OpenCode first-class. Listed AFTER the existing
+    // runtimes so multi-runtime machines keep their current default
+    // (detection picks the first match).
+    id: "opencode",
+    name: "OpenCode",
+    detect: () => {
+      try {
+        execSync("opencode --version", { stdio: "pipe" });
+        return true;
+      } catch {
+        return existsSync(join(homedir(), ".config", "opencode"));
+      }
+    },
+    configDir: () => join(homedir(), ".config", "opencode"),
+    skillsDir: () => join(homedir(), ".config", "opencode", "commands"),
+    settingsFile: () => join(homedir(), ".config", "opencode", "opencode.json"),
+  },
 ];
 
 export async function detectRuntime() {

package/installer/doctor.js

@@ -7,9 +7,40 @@ import { IS_WINDOWS, HOOK_EXT, CMD_FINDER } from "./platform.js";
 import { checkNode, checkObsidian, checkOllama } from "./system-tools.js";
 import { graphifyDoctor } from "./graphify.js";
 import { status as autoupdateStatus } from "./autoupdate.js";
+import { normalizeProfileFlag, profileIncludes } from "./profile.js";
+import {
+  loadProfilesManifest,
+  parseExecutionModel,
+  resolveServicesForProfile,
+} from "./services.js";
+import { menubarHealthy } from "./menubar.js";
 
 const INSTALL_DIR = join(homedir(), ".arkaos");
 
+// ─── Install-profile awareness (Foundation PR-4) ────────────────────────
+// Checks may declare `minProfile`; when the machine's persisted profile
+// sits below it on the ladder (essential ⊂ complete ⊂ local-ai) the
+// check reports "skipped (not in <profile> profile)" instead of a
+// misleading warn — an essential machine without Ollama is healthy.
+
+export function currentInstallProfile(
+  profilePath = join(INSTALL_DIR, "profile.json")
+) {
+  try {
+    const profile = JSON.parse(readFileSync(profilePath, "utf-8"));
+    return normalizeProfileFlag(profile.installProfile) || "essential";
+  } catch {
+    return "essential";
+  }
+}
+
+/** Null when the check applies; otherwise the human-readable skip reason. */
+export function checkSkipReason(check, activeProfile) {
+  if (!check.minProfile) return null;
+  if (profileIncludes(activeProfile, check.minProfile)) return null;
+  return `not in ${activeProfile} profile`;
+}
+
 // Resolve a single command via the platform-native locator. Returns true
 // when the command is discoverable on PATH, false otherwise. stderr is
 // suppressed through Node's stdio option so the probe does not print
@@ -414,6 +445,7 @@ export const checks = [
     name: "ollama",
     description: "Ollama present (optional — cognitive layer LLM runtime)",
     severity: "warn",
+    minProfile: "local-ai",
     check: () => checkOllama().installed,
     fix: () => {
       const s = checkOllama();
@@ -500,6 +532,7 @@ export const checks = [
     name: "ffmpeg",
     description: "FFmpeg present (video encode/cut for Hyperframes + transcription workflows)",
     severity: "warn",
+    minProfile: "complete",
     check: () => commandExists("ffmpeg"),
     fix: () => "Install FFmpeg: brew install ffmpeg (macOS) / apt install ffmpeg (Linux) / winget install Gyan.FFmpeg (Windows)",
   },
@@ -625,6 +658,120 @@ export const checks = [
     check: () => companionPluginsInstalled(),
     fix: () => "claude plugin marketplace add obra/superpowers-marketplace && claude plugin install superpowers@superpowers-marketplace; claude plugin marketplace add thedotmack/claude-mem && claude plugin install claude-mem@thedotmack",
   },
+  // ─── Install-profile checks (Foundation PR-4) — all warn-only ─────────
+  {
+    name: "install-profile",
+    description: "Install profile valid (profile.json + install-profiles manifest)",
+    severity: "warn",
+    check: () => {
+      // A profile.json that predates PR-3 (no installProfile key) is
+      // valid — it means essential. An explicitly invalid value or an
+      // unloadable/unresolvable manifest is the failure.
+      const profilePath = join(INSTALL_DIR, "profile.json");
+      if (existsSync(profilePath)) {
+        try {
+          const profile = JSON.parse(readFileSync(profilePath, "utf-8"));
+          if (
+            profile.installProfile !== undefined &&
+            !normalizeProfileFlag(profile.installProfile)
+          ) {
+            return false;
+          }
+        } catch {
+          return false;
+        }
+      }
+      const repoRoot = getRepoRoot();
+      if (!repoRoot) return true; // no repo reference — not a profile problem
+      try {
+        const manifest = loadProfilesManifest(repoRoot);
+        resolveServicesForProfile(currentInstallProfile(), manifest);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    fix: () =>
+      "profile.json installProfile must be one of essential|complete|local-ai; refresh the manifest via: npx arkaos@latest update",
+  },
+  {
+    name: "litellm-proxy",
+    description: "LiteLLM proxy installed (gateway prerequisite — complete profile)",
+    severity: "warn",
+    minProfile: "complete",
+    check: () => {
+      const py = getArkaosPython();
+      if (!py) return false;
+      try {
+        execSync(`"${py}" -c "import litellm"`, { stdio: "ignore", timeout: 30000 });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    fix: () =>
+      "Run: ~/.arkaos/venv/bin/pip install 'litellm[proxy]'  (or: npx arkaos doctor --fix)",
+  },
+  {
+    name: "whisper",
+    description: "Whisper transcription installed (faster-whisper — complete profile)",
+    severity: "warn",
+    minProfile: "complete",
+    check: () => {
+      const py = getArkaosPython();
+      if (!py) return false;
+      try {
+        execSync(`"${py}" -c "import faster_whisper"`, { stdio: "ignore", timeout: 30000 });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    fix: () =>
+      "Run: ~/.arkaos/venv/bin/pip install faster-whisper  (or: npx arkaos doctor --fix)",
+  },
+  {
+    name: "ollama-execution-model",
+    description: "Local execution model pulled (Model Fabric — local-ai profile)",
+    severity: "warn",
+    minProfile: "local-ai",
+    check: () => {
+      const resolved = parseExecutionModel();
+      // No ollama execution role in models.yaml — nothing to verify.
+      if (!resolved) return true;
+      try {
+        const out = execSync("ollama list", {
+          stdio: ["ignore", "pipe", "ignore"],
+          timeout: 10000,
+        }).toString();
+        return out.split(/\r?\n/).some((line) => {
+          const token = line.trim().split(/\s+/)[0];
+          return (
+            token === resolved.model ||
+            (!resolved.model.includes(":") && token.split(":")[0] === resolved.model)
+          );
+        });
+      } catch {
+        return false;
+      }
+    },
+    fix: () => {
+      const resolved = parseExecutionModel();
+      return resolved
+        ? `Run: ollama pull ${resolved.model}  (or: npx arkaos doctor --fix)`
+        : "Configure: npx arkaos models set execution ollama/<model>";
+    },
+  },
+  {
+    name: "menubar",
+    description: "Menu bar launcher running (macOS — ▲ quick actions)",
+    severity: "warn",
+    // Live probe, not file decoration: menubarHealthy composes file
+    // presence + opt-out semantics + `launchctl list` (QG M2). Every
+    // branch is unit-tested via the injectable exec in menubar.test.js.
+    check: () => menubarHealthy(),
+    fix: () => "Run: npx arkaos menubar enable  (opt-out permanently: npx arkaos menubar disable)",
+  },
 ];
 
 // ─── Windows-only checks ───────────────────────────────────────────────
@@ -709,14 +856,50 @@ export async function doctor(options = {}) {
         console.log(`  ✗ Venv repair failed (${result.reason})`);
       }
     }
+
+    // ─── --fix: reconcile the install profile's services (PR-4) ──────
+    // Non-interactive: consent-free services (pip into our venv, model
+    // pull) install; consent-gated ones print the exact command. Never
+    // blocks — a reconcile error degrades to a single warning line.
+    try {
+      const repoRoot = getRepoRoot();
+      if (repoRoot) {
+        const activeProfile = currentInstallProfile();
+        console.log(`  → Reconciling ${activeProfile} profile services`);
+        const { reconcileServices } = await import("./services.js");
+        const results = await reconcileServices({
+          profile: activeProfile,
+          repoRoot,
+          interactive: false,
+          log: (msg) => console.log("    " + String(msg).trim()),
+        });
+        for (const r of results) {
+          if (r.status === "installed") console.log(`  ✓ ${r.label} installed`);
+          else if (r.status === "failed") console.log(`  ✗ ${r.label} failed${r.hint ? ` — ${r.hint}` : ""}`);
+          else if (r.status === "skipped") console.log(`  · ${r.label} skipped${r.hint ? ` — ${r.hint}` : ""}`);
+        }
+      }
+    } catch (err) {
+      console.log(`  ⚠ Service reconciliation skipped (${err.message})`);
+    }
     console.log("");
   }
 
+  const activeProfile = currentInstallProfile();
   let passed = 0;
   let warned = 0;
   let failed = 0;
+  let skipped = 0;
 
   for (const check of checks) {
+    // Profile gate (PR-4): below-profile checks are informational
+    // skips, not warnings — see checkSkipReason.
+    const skipReason = checkSkipReason(check, activeProfile);
+    if (skipReason) {
+      console.log(`  \x1b[90m-\x1b[0m  ${check.description} — skipped (${skipReason})`);
+      skipped++;
+      continue;
+    }
     // A single check that throws must not crash the rest of the doctor.
     // Treat the exception as "check failed" and record a short hint so
     // the user can see what blew up. Also keep any stack-trace noise
@@ -752,7 +935,8 @@ export async function doctor(options = {}) {
     }
   }
 
-  console.log(`\n  Results: ${passed} passed, ${warned} warnings, ${failed} failures\n`);
+  const skippedSuffix = skipped > 0 ? `, ${skipped} skipped` : "";
+  console.log(`\n  Results: ${passed} passed, ${warned} warnings, ${failed} failures${skippedSuffix}\n`);
   await securityAdvisory();
   if (failed > 0) process.exit(1);
 }
@@ -763,10 +947,26 @@ export async function doctor(options = {}) {
 // (core.governance.harness_scanner_cli).
 function doctorJson() {
   const results = [];
+  const activeProfile = currentInstallProfile();
   let passed = 0;
   let warned = 0;
   let failed = 0;
+  let skipped = 0;
   for (const check of checks) {
+    // Profile gate (PR-4) — same skip semantics as the human run.
+    const skipReason = checkSkipReason(check, activeProfile);
+    if (skipReason) {
+      skipped++;
+      results.push({
+        name: check.name,
+        status: "skipped",
+        severity: check.severity,
+        description: check.description,
+        fix: "",
+        skipReason,
+      });
+      continue;
+    }
     let ok = false;
     let error = null;
     try {
@@ -792,7 +992,7 @@ function doctorJson() {
   }
   console.log(JSON.stringify({
     checks: results,
-    summary: { passed, warned, failed, total: results.length },
+    summary: { passed, warned, failed, skipped, total: results.length },
   }));
   if (failed > 0) process.exit(1);
 }