@kal-elsam/kairo-runtime 0.1.4 → 0.2.0

package/src/global/agent-capabilities/index.js

@@ -0,0 +1,54 @@
+import cursorManaged from "../adapters/cursor.js";
+import codexManaged from "../adapters/codex.js";
+import opencodeManaged from "../adapters/opencode.js";
+import claudeManaged from "../adapters/claude.js";
+import { createAgentCapabilityAdapter } from "./create-capability-adapter.js";
+
+const cursor = createAgentCapabilityAdapter({
+  id: "cursor",
+  label: "Cursor",
+  managedAdapter: cursorManaged,
+  executable: "cursor",
+  opaqueAuth: true
+});
+
+const codex = createAgentCapabilityAdapter({
+  id: "codex",
+  label: "Codex",
+  managedAdapter: codexManaged,
+  executable: "codex",
+  runExecutable: "codex"
+});
+
+const opencode = createAgentCapabilityAdapter({
+  id: "opencode",
+  label: "OpenCode",
+  managedAdapter: opencodeManaged,
+  executable: "opencode",
+  runExecutable: "opencode"
+});
+
+const claude = createAgentCapabilityAdapter({
+  id: "claude",
+  label: "Claude Code",
+  managedAdapter: claudeManaged,
+  executable: "claude",
+  authArgs: ["auth", "status"],
+  runExecutable: "claude"
+});
+
+const CAPABILITY_ADAPTERS = [cursor, codex, opencode, claude];
+
+export const AGENT_CAPABILITY_IDS = CAPABILITY_ADAPTERS.map((adapter) => adapter.id);
+
+export function listCapabilityAdapters() {
+  return [...CAPABILITY_ADAPTERS];
+}
+
+export function resolveCapabilityAdapter(id) {
+  const adapter = CAPABILITY_ADAPTERS.find((candidate) => candidate.id === id);
+  if (!adapter) {
+    throw new Error(`Unknown agent capability "${id}". Use ${AGENT_CAPABILITY_IDS.join(", ")}.`);
+  }
+  return adapter;
+}

package/src/global/brand/cli.js

@@ -51,9 +51,9 @@ export function formatCliCommand(subcommand, cliName = PREFERRED_CLI) {
   return trimmed ? `${cliName} ${trimmed}` : cliName;
 }
 
-function detectInvocationPackageManager() {
-  const execPath = process.env.npm_execpath ?? "";
-  const userAgent = process.env.npm_config_user_agent ?? "";
+function detectInvocationPackageManager(env = process.env) {
+  const execPath = env.npm_execpath ?? "";
+  const userAgent = env.npm_config_user_agent ?? "";
 
   if (execPath.includes("pnpm") || userAgent.startsWith("pnpm/")) return "pnpm";
   if (execPath.includes("yarn") || userAgent.startsWith("yarn/")) return "yarn";
@@ -61,7 +61,11 @@ function detectInvocationPackageManager() {
   return "npm";
 }
 
-export function resolveSuggestedInvocation(packageName = PACKAGE_NAME, argv = process.argv) {
+export function resolveSuggestedInvocation(
+  packageName = PACKAGE_NAME,
+  argv = process.argv,
+  { env = process.env } = {}
+) {
   const invokedPath = argv[1] ?? PREFERRED_CLI;
   const invokedBase = basename(invokedPath);
 
@@ -69,7 +73,7 @@ export function resolveSuggestedInvocation(packageName = PACKAGE_NAME, argv = pr
     return invokedBase;
   }
 
-  const packageManager = detectInvocationPackageManager();
+  const packageManager = detectInvocationPackageManager(env);
 
   switch (packageManager) {
     case "pnpm":
@@ -85,9 +89,9 @@ export function resolveSuggestedInvocation(packageName = PACKAGE_NAME, argv = pr
 
 export function formatSuggestedCliCommand(
   subcommand,
-  { packageName = PACKAGE_NAME, argv = process.argv, suggestedInvocation } = {}
+  { packageName = PACKAGE_NAME, argv = process.argv, suggestedInvocation, env = process.env } = {}
 ) {
-  const invoke = suggestedInvocation ?? resolveSuggestedInvocation(packageName, argv);
+  const invoke = suggestedInvocation ?? resolveSuggestedInvocation(packageName, argv, { env });
   const trimmed = subcommand.trim();
   return trimmed ? `${invoke} ${trimmed}` : invoke;
 }

package/src/global/capability-registry.js

@@ -0,0 +1,80 @@
+import { buildAdapterContext } from "./adapter-context.js";
+import { CAPABILITY_STATES } from "./capability-states.js";
+import {
+  AGENT_CAPABILITY_IDS,
+  listCapabilityAdapters,
+  resolveCapabilityAdapter
+} from "./agent-capabilities/index.js";
+
+export async function inspectAllCapabilities({
+  homeDir,
+  workspaceRoot = process.cwd(),
+  packageName = "@kal-elsam/kairo-runtime",
+  probeOverrides = null
+} = {}) {
+  const context = buildAdapterContext({ homeDir, workspaceRoot, packageName });
+  const adapters = listCapabilityAdapters();
+
+  return Promise.all(adapters.map(async (adapter) => {
+    const probeOptions = probeOverrides?.[adapter.id] ?? {};
+    const inspection = adapter.inspect(context, probeOptions);
+    const models = adapter.listModels?.(context, probeOptions) ?? null;
+
+    return {
+      ...inspection,
+      models
+    };
+  }));
+}
+
+export async function inspectCapability(agentId, context, probeOptions = {}) {
+  const adapter = resolveCapabilityAdapter(agentId);
+  const inspection = adapter.inspect(context, probeOptions);
+  const models = adapter.listModels?.(context, probeOptions) ?? null;
+  return { ...inspection, models };
+}
+
+export function summarizeCapabilityRegistry(capabilities) {
+  const byState = {};
+  for (const state of Object.values(CAPABILITY_STATES)) {
+    byState[state] = 0;
+  }
+
+  for (const capability of capabilities) {
+    if (byState[capability.state] != null) {
+      byState[capability.state] += 1;
+    }
+  }
+
+  return {
+    total: capabilities.length,
+    supported: AGENT_CAPABILITY_IDS.length,
+    detected: capabilities.filter((entry) => entry.detected).length,
+    available: capabilities.filter((entry) => entry.state === CAPABILITY_STATES.AVAILABLE).length,
+    byState
+  };
+}
+
+export function buildCapabilityDiagnostics(capabilities) {
+  const recommendations = capabilities
+    .map((entry) => entry.recommendation)
+    .filter(Boolean);
+
+  const errors = capabilities
+    .filter((entry) => entry.state === CAPABILITY_STATES.ERROR)
+    .map((entry) => ({
+      agent: entry.id,
+      message: entry.error ?? entry.recommendation ?? "Inspection failed."
+    }));
+
+  return {
+    recommendations,
+    errors,
+    hasActionableErrors: errors.length > 0
+  };
+}
+
+export function delegateToAgent(agentId, context, runOptions = {}) {
+  const adapter = resolveCapabilityAdapter(agentId);
+  return adapter.run(context, runOptions);
+}

package/src/global/capability-states.js

@@ -0,0 +1,30 @@
+export const CAPABILITY_STATES = {
+  DETECTED: "detected",
+  AUTHENTICATED: "authenticated",
+  AVAILABLE: "available",
+  UNKNOWN: "unknown",
+  ERROR: "error"
+};
+
+export function isCapabilityState(value) {
+  return Object.values(CAPABILITY_STATES).includes(value);
+}
+
+export function formatCapabilityState(state) {
+  switch (state) {
+    case CAPABILITY_STATES.DETECTED:
+      return "detected";
+    case CAPABILITY_STATES.AUTHENTICATED:
+      return "authenticated";
+    case CAPABILITY_STATES.AVAILABLE:
+      return "available";
+    case CAPABILITY_STATES.UNKNOWN:
+      return "unknown";
+    case CAPABILITY_STATES.ERROR:
+      return "error";
+    default: {
+      const _exhaustive = state;
+      return String(_exhaustive);
+    }
+  }
+}

package/src/global/cli-probe.js

@@ -0,0 +1,47 @@
+import { spawnSync } from "node:child_process";
+
+const DEFAULT_TIMEOUT_MS = 5000;
+
+export function isExecutableAvailable(command, { env = process.env } = {}) {
+  const result = spawnSync("which", [command], { encoding: "utf8", env });
+  return result.status === 0 && result.stdout.trim().length > 0;
+}
+
+export function probeCommand(command, args = [], {
+  cwd = process.cwd(),
+  env = process.env,
+  timeoutMs = DEFAULT_TIMEOUT_MS
+} = {}) {
+  const result = spawnSync(command, args, {
+    cwd,
+    env,
+    encoding: "utf8",
+    timeout: timeoutMs
+  });
+
+  return {
+    ok: result.status === 0,
+    status: result.status,
+    stdout: (result.stdout ?? "").trim(),
+    stderr: (result.stderr ?? "").trim(),
+    error: result.error?.message ?? null,
+    timedOut: result.error?.code === "ETIMEDOUT"
+  };
+}
+
+export function parseVersionFromOutput(output) {
+  if (!output) return null;
+
+  const match = output.match(/(\d+\.\d+(?:\.\d+)?(?:[-+][\w.]+)?)/);
+  return match?.[1] ?? null;
+}
+
+export function resolveProbeState({ detected, cliAvailable, authReady, probeError, opaque = false }) {
+  if (probeError) return "error";
+  if (opaque) return "unknown";
+  if (!detected && !cliAvailable) return "unknown";
+  if (cliAvailable && authReady) return "available";
+  if (authReady) return "authenticated";
+  if (detected || cliAvailable) return "detected";
+  return "unknown";
+}

package/src/global/ink/orchestrator-app.js

@@ -0,0 +1,224 @@
+import React, { useEffect, useState } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import { BRAND } from "../brand/index.js";
+import { PLAN_ACTIONS, buildActionPlan, buildReadOnlyDiagnostics } from "../action-planner.js";
+import { buildProfileJson, resolveProfile } from "../profile.js";
+import {
+  ORCHESTRATOR_MENU,
+  ORCHESTRATOR_VIEWS,
+  formatAgentStatusLines,
+  formatIntelligenceLines,
+  formatPlanLines,
+  formatProfileLines
+} from "./orchestrator-state.js";
+
+const COLORS = {
+  accent: "cyan",
+  success: "green",
+  warning: "yellow",
+  danger: "red",
+  muted: "gray"
+};
+
+export function OrchestratorApp({
+  homeDir,
+  workspaceRoot,
+  packageName,
+  packageRoot,
+  cliVersion,
+  onComplete
+}) {
+  const { exit } = useApp();
+  const [view, setView] = useState(ORCHESTRATOR_VIEWS.HOME);
+  const [menuIndex, setMenuIndex] = useState(0);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [diagnostics, setDiagnostics] = useState(null);
+  const [profileJson, setProfileJson] = useState(null);
+  const [plan, setPlan] = useState(null);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    async function load() {
+      try {
+        const [diag, profileResolved] = await Promise.all([
+          buildReadOnlyDiagnostics({ homeDir, workspaceRoot, packageName, packageRoot, cliVersion }),
+          resolveProfile({ homeDir, workspaceRoot })
+        ]);
+
+        if (cancelled) return;
+        setDiagnostics(diag);
+        setProfileJson(buildProfileJson(profileResolved));
+        setLoading(false);
+      } catch (loadError) {
+        if (cancelled) return;
+        setError(loadError instanceof Error ? loadError.message : String(loadError));
+        setLoading(false);
+      }
+    }
+
+    load();
+    return () => {
+      cancelled = true;
+    };
+  }, [homeDir, workspaceRoot, packageName, packageRoot, cliVersion]);
+
+  const finish = (outcome) => {
+    onComplete(outcome);
+    exit();
+  };
+
+  useInput((inputKey, key) => {
+    if (key.escape) {
+      if (view === ORCHESTRATOR_VIEWS.HOME) {
+        finish({ cancelled: true });
+        return;
+      }
+      setView(ORCHESTRATOR_VIEWS.HOME);
+      setPlan(null);
+      return;
+    }
+
+    if (loading || error) return;
+
+    if (view === ORCHESTRATOR_VIEWS.CONFIRM) {
+      if (inputKey.toLowerCase() === "y") {
+        finish({ cancelled: false, action: plan?.action ?? PLAN_ACTIONS.SETUP, confirmed: true, plan });
+      }
+      if (inputKey.toLowerCase() === "n") {
+        setView(ORCHESTRATOR_VIEWS.HOME);
+        setPlan(null);
+      }
+      return;
+    }
+
+    if (view !== ORCHESTRATOR_VIEWS.HOME) return;
+
+    if (key.upArrow) {
+      setMenuIndex((index) => Math.max(0, index - 1));
+      return;
+    }
+
+    if (key.downArrow) {
+      setMenuIndex((index) => Math.min(ORCHESTRATOR_MENU.length - 1, index + 1));
+      return;
+    }
+
+    if (!key.return) return;
+
+    const item = ORCHESTRATOR_MENU[menuIndex];
+    if (item.action === "setup") {
+      buildActionPlan({
+        action: PLAN_ACTIONS.SETUP,
+        homeDir,
+        workspaceRoot,
+        packageName,
+        options: { packageRoot, cliVersion }
+      }).then((builtPlan) => {
+        setPlan(builtPlan);
+        setView(ORCHESTRATOR_VIEWS.CONFIRM);
+      }).catch((planError) => {
+        setError(planError instanceof Error ? planError.message : String(planError));
+      });
+      return;
+    }
+
+    setView(item.view);
+  });
+
+  if (loading) {
+    return React.createElement(Box, { flexDirection: "column" },
+      React.createElement(Text, { bold: true, color: COLORS.accent }, BRAND.displayName),
+      React.createElement(Text, { color: COLORS.muted }, "Loading agent capabilities…")
+    );
+  }
+
+  if (error) {
+    return React.createElement(Box, { flexDirection: "column" },
+      React.createElement(Text, { bold: true, color: COLORS.danger }, "Orchestrator error"),
+      React.createElement(Text, null, error),
+      React.createElement(Text, { dimColor: true }, "Esc to exit")
+    );
+  }
+
+  return React.createElement(Box, { flexDirection: "column" },
+    React.createElement(Text, { bold: true, color: COLORS.accent }, `${BRAND.displayName} orchestrator`),
+    React.createElement(Text, { color: COLORS.muted }, "Harness Engineering · local-first · cloud opt-in"),
+    React.createElement(Text, null, ""),
+    renderView({ view, diagnostics, profileJson, plan, menuIndex }),
+    React.createElement(Text, null, ""),
+    React.createElement(Text, { dimColor: true }, footerHint(view))
+  );
+}
+
+function renderView({ view, diagnostics, profileJson, plan, menuIndex }) {
+  switch (view) {
+    case ORCHESTRATOR_VIEWS.HOME:
+      return React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, { bold: true }, "Menu"),
+        ORCHESTRATOR_MENU.map((item, index) =>
+          React.createElement(Text, {
+            key: item.id,
+            color: index === menuIndex ? COLORS.accent : undefined,
+            bold: index === menuIndex
+          }, `${index === menuIndex ? "› " : "  "}${item.label}`)
+        ),
+        React.createElement(Text, null, ""),
+        React.createElement(Text, { bold: true }, "Snapshot"),
+        React.createElement(Text, null, `Agents detected: ${diagnostics.diagnostics.detected}/${diagnostics.capabilities.length}`),
+        React.createElement(Text, null, `Available: ${diagnostics.diagnostics.available}`),
+        diagnostics.intelligence && React.createElement(
+          Text,
+          null,
+          `Intelligence: local=${diagnostics.intelligence.summary.localAvailable ? "yes" : "no"} cloud=${diagnostics.intelligence.summary.cloudAuthenticated ? "yes" : "no"}`
+        )
+      );
+    case ORCHESTRATOR_VIEWS.AGENTS:
+      return React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, { bold: true }, "Agent capabilities"),
+        formatAgentStatusLines(diagnostics.capabilities)
+          .map((line) => React.createElement(Text, { key: line }, line))
+      );
+    case ORCHESTRATOR_VIEWS.INTELLIGENCE:
+      return React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, { bold: true }, "Intelligence backends"),
+        formatIntelligenceLines(diagnostics)
+          .map((line) => React.createElement(Text, { key: line }, line)),
+        React.createElement(Text, null, ""),
+        React.createElement(Text, { dimColor: true }, "CLI: kairo intelligence status|models|context|route|ask")
+      );
+    case ORCHESTRATOR_VIEWS.PROFILE:
+      return React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, { bold: true }, "Profile"),
+        formatProfileLines(profileJson)
+          .map((line) => React.createElement(Text, { key: line }, line))
+      );
+    case ORCHESTRATOR_VIEWS.PLAN:
+    case ORCHESTRATOR_VIEWS.CONFIRM:
+      return React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, { bold: true }, view === ORCHESTRATOR_VIEWS.CONFIRM ? "Confirm plan" : "Plan"),
+        plan && formatPlanLines(plan).map((line) => React.createElement(Text, { key: line }, line)),
+        view === ORCHESTRATOR_VIEWS.CONFIRM && React.createElement(Text, { color: COLORS.warning }, "Y confirm · N decline")
+      );
+    case ORCHESTRATOR_VIEWS.HELP:
+      return React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Text, { bold: true }, "Help"),
+        React.createElement(Text, null, "Kairo coordinates installed agent CLIs and governs project intelligence."),
+        React.createElement(Text, null, "Local-first: Ollama when available. Cloud (OpenRouter/free) needs consent."),
+        React.createElement(Text, null, "Use: intelligence status|models|context|route|ask"),
+        React.createElement(Text, null, "Profiles: ~/.harness/profile.json and .harness/kairo.json (project wins)."),
+        React.createElement(Text, null, "Credentials are never stored by Kairo — use environment variables.")
+      );
+    default: {
+      const _exhaustive = view;
+      return React.createElement(Text, null, `Unknown view: ${_exhaustive}`);
+    }
+  }
+}
+
+function footerHint(view) {
+  if (view === ORCHESTRATOR_VIEWS.HOME) return "↑↓ navigate · Enter select · Esc quit";
+  if (view === ORCHESTRATOR_VIEWS.CONFIRM) return "Y confirm · N decline · Esc back";
+  return "Esc back to menu";
+}

package/src/global/ink/orchestrator-state.js

@@ -0,0 +1,107 @@
+import { stdin as input, stdout as output } from "node:process";
+import { canUseSetupInk } from "./terminal.js";
+
+export function canUseOrchestratorShell({
+  interactive = Boolean(input.isTTY && output.isTTY),
+  term = process.env.TERM ?? "",
+  columns = output.columns ?? 80,
+  forceInk = process.env.HARNESS_INK !== "0"
+} = {}) {
+  return canUseSetupInk({ interactive, term, columns, forceInk });
+}
+
+export const ORCHESTRATOR_VIEWS = {
+  HOME: "home",
+  AGENTS: "agents",
+  PROFILE: "profile",
+  PLAN: "plan",
+  CONFIRM: "confirm",
+  HELP: "help",
+  INTELLIGENCE: "intelligence"
+};
+
+export const ORCHESTRATOR_MENU = [
+  { id: "status", label: "Diagnostics", view: ORCHESTRATOR_VIEWS.HOME },
+  { id: "agents", label: "Agents", view: ORCHESTRATOR_VIEWS.AGENTS },
+  { id: "intelligence", label: "Intelligence", view: ORCHESTRATOR_VIEWS.INTELLIGENCE },
+  { id: "profile", label: "Profile", view: ORCHESTRATOR_VIEWS.PROFILE },
+  { id: "plan-setup", label: "Plan setup", view: ORCHESTRATOR_VIEWS.PLAN, action: "setup" },
+  { id: "help", label: "Help", view: ORCHESTRATOR_VIEWS.HELP }
+];
+
+export function formatAgentStatusLines(capabilities) {
+  return capabilities.map((entry) => {
+    const auth = entry.authenticated == null ? "n/a" : (entry.authenticated ? "yes" : "no");
+    const version = entry.version ?? "unknown";
+    return `${entry.label.padEnd(14)} ${entry.state.padEnd(14)} v${version} auth=${auth}`;
+  });
+}
+
+export function formatProfileLines(profileJson) {
+  const lines = [
+    `Coordinator: ${profileJson.coordinator ?? "none"}`,
+    `Default agents: ${formatAgentsLabel(profileJson.defaultAgents)}`,
+    `Apply mode: ${profileJson.applyMode}`,
+    `Preferred backend: ${profileJson.preferredBackend ?? "auto"}`,
+    `Preferred model: ${profileJson.preferredModel ?? "auto"}`,
+    `Cloud consent preference: ${profileJson.cloudConsent ? "recorded (session --cloud-consent still required)" : "no"}`,
+    `Token budget: ${profileJson.tokenBudget ?? "none"}`
+  ];
+
+  if (profileJson.sources.global) {
+    lines.push(`Global: ${profileJson.sources.global}`);
+  }
+
+  if (profileJson.sources.project) {
+    lines.push(`Project: ${profileJson.sources.project}`);
+  }
+
+  lines.push(`Precedence: ${profileJson.sources.precedence}`);
+  return lines;
+}
+
+export function formatIntelligenceLines(diagnostics) {
+  const intelligence = diagnostics?.intelligence;
+  if (!intelligence) {
+    return ["Intelligence layer unavailable."];
+  }
+
+  const lines = [
+    `Local available: ${intelligence.summary.localAvailable ? "yes" : "no"}`,
+    `Cloud authenticated: ${intelligence.summary.cloudAuthenticated ? "yes" : "no"}`,
+    `Routing: ${intelligence.routingPreview?.reason ?? "n/a"}`,
+    `Can invoke: ${intelligence.routingPreview?.canInvoke ? "yes" : "no"}`,
+    ""
+  ];
+
+  for (const backend of intelligence.backends ?? []) {
+    lines.push(
+      `${backend.label.padEnd(14)} ${backend.state.padEnd(14)} models=${backend.models?.length ?? 0}`
+    );
+  }
+
+  return lines;
+}
+
+export function formatPlanLines(plan) {
+  const lines = [`Action: ${plan.action}`, ""];
+  for (const step of plan.steps) {
+    lines.push(`  • ${step}`);
+  }
+
+  if (plan.warnings.length > 0) {
+    lines.push("", "Warnings:");
+    for (const warning of plan.warnings) {
+      lines.push(`  ! ${warning}`);
+    }
+  }
+
+  return lines;
+}
+
+function formatAgentsLabel(agents) {
+  if (agents === "detected") return "detected";
+  if (agents === "all") return "all";
+  if (Array.isArray(agents)) return agents.join(", ");
+  return String(agents);
+}

package/src/global/ink/run-orchestrator-ink.js

@@ -0,0 +1,29 @@
+import React from "react";
+import { render } from "ink";
+import { OrchestratorApp } from "./orchestrator-app.js";
+
+export async function runOrchestratorInk({
+  homeDir,
+  workspaceRoot,
+  packageRoot,
+  packageName,
+  cliVersion,
+  renderImpl = render
+}) {
+  return new Promise((resolve) => {
+    const { waitUntilExit } = renderImpl(
+      React.createElement(OrchestratorApp, {
+        homeDir,
+        workspaceRoot,
+        packageRoot,
+        packageName,
+        cliVersion,
+        onComplete: resolve
+      })
+    );
+
+    waitUntilExit().catch((error) => {
+      resolve({ cancelled: true, error });
+    });
+  });
+}