avorelo 0.1.0

package/scripts/lib/orchestration/cli.js

@@ -0,0 +1,438 @@
+"use strict";
+
+const {
+  routeTask,
+  runTask,
+  buildOrchestrationStatus,
+  buildAgentModelOrchestrationSurface,
+  generateHandoff,
+  modelsText,
+  readCurrentProof,
+  proofText,
+  buildTaskContext,
+} = require("./index");
+const { verifyWorkspace } = require("./verification-manager");
+const { buildStatusDashboard } = require("../dashboard");
+const { getCurrentPlan, canExportReports } = require("../entitlements");
+const { appendProMomentEvent } = require("../pro-moment-events");
+const {
+  buildCompactProMomentLines,
+  buildProMomentSurface,
+  recordProMomentEvaluation,
+} = require("../pro-moments");
+const {
+  exportProofHistoryBundle,
+  formatProofExportText,
+  formatProofHistoryText,
+  readProofHistory,
+} = require("../proof-history");
+const {
+  getSettings,
+  setMode,
+  setBooleanFlag,
+  setWorkerEnabled,
+  formatSettingsText,
+} = require("./settings");
+const { loadInventory } = require("./inventory");
+
+function taskFromArgs(args) {
+  return args.filter((arg) => !arg.startsWith("--")).join(" ").trim();
+}
+
+function wantsJson(args) {
+  return args.includes("--json");
+}
+
+function parseSurface(args) {
+  const found = args.find((arg) => arg.startsWith("--surface="));
+  return found ? found.split("=").slice(1).join("=") : "avorelo_cli";
+}
+
+function parseBool(value) {
+  return ["1", "true", "yes", "on"].includes(String(value).toLowerCase());
+}
+
+function wantsHistory(args = []) {
+  return args.includes("--history");
+}
+
+function wantsExport(args = []) {
+  return args.includes("--export");
+}
+
+function buildProofDepthPayload(surface) {
+  return {
+    momentId: surface.momentId,
+    surface: surface.surface,
+    displayLevel: surface.displayLevel,
+    reasonCodes: surface.reasonCodes || [],
+    blockedReasonCodes: surface.blockedReasonCodes || [],
+    plan: surface.plan,
+    sessionCount: surface.sessionCount,
+    valueEventsCount: surface.valueEventsCount,
+    dismissCount: surface.dismissCount,
+    cooldownActive: surface.cooldownActive,
+    nextEligibleAt: surface.nextEligibleAt,
+  };
+}
+
+function buildProofDepthSurface(cwd, momentSurface, featureRequested) {
+  const status = buildStatusDashboard(cwd, { limit: 7 });
+  return buildProMomentSurface(cwd, {
+    surface: momentSurface,
+    status,
+    momentId: "evidence_history_export",
+    featureRequested,
+    userAction: featureRequested,
+    proactive: true,
+    respectRecentShown: false,
+  });
+}
+
+function renderFreeProofDepthText(baseText, surface) {
+  const lines = [String(baseText || "").trimEnd()];
+  const proLines = buildCompactProMomentLines(surface);
+  if (proLines.length) {
+    lines.push("");
+    lines.push(...proLines);
+  }
+  return `${lines.filter(Boolean).join("\n")}\n`;
+}
+
+function buildFreeProofDepthJson(proof, surface, extras = {}) {
+  return {
+    proof: proof || {},
+    proMoment: surface,
+    checkoutStarted: false,
+    accountRequired: false,
+    ...extras,
+  };
+}
+
+function formatWorkerNotes(inventory) {
+  const tools = Array.isArray(inventory?.tools) ? inventory.tools : [];
+  const notes = [];
+  const gemini = tools.find((tool) => tool.toolId === "gemini_cli");
+  const lmStudio = tools.find((tool) => tool.toolId === "lm_studio");
+
+  if (gemini?.installStatus === "installed_not_on_path") {
+    notes.push("Gemini CLI command not found on PATH");
+  } else if (gemini?.availability === "needs_login") {
+    notes.push("Gemini CLI needs login");
+  }
+
+  if (lmStudio?.installStatus === "installed_or_configured_but_not_running") {
+    notes.push("LM Studio local server not running");
+  } else if (lmStudio?.installStatus === "configured_but_no_models") {
+    notes.push("LM Studio server reachable but no models are loaded");
+  }
+
+  return notes.length > 0 ? notes.join("; ") : null;
+}
+
+function renderRouteCommand(cwd, args = []) {
+  const taskText = taskFromArgs(args);
+  if (!taskText) throw new Error("`avorelo route` requires a task.");
+  const result = routeTask(cwd, taskText, {
+    surface: parseSurface(args),
+    refreshInventory: args.includes("--refresh"),
+  });
+
+  if (wantsJson(args)) return JSON.stringify(result.route, null, 2);
+
+  // Auto-write value summary after routing (best-effort)
+  try {
+    const { writeSeamlessRunReceipt, formatCompactRouteLine, getDecisionVisibility } = require("../seamless-enforcement");
+    const visibility = getDecisionVisibility({
+      actionType: "model_worker_routing",
+      riskLevel: result.taskContext.classification.risk || "low",
+    });
+    writeSeamlessRunReceipt(cwd, {
+      command: "route",
+      manualDecisionsAvoided: 1,
+      strongWorkerReservedForCriticalStage: result.route.premiumUseInvolved === true,
+      escalationRecommended: (result.route.fallbackReasonCodes || []).includes("ESCALATION_RECOMMENDED"),
+      userInterruptAvoided: !visibility.interruptRequired,
+    });
+    // In automatic mode, show compact outcome line
+    if (!visibility.showDetail) {
+      return formatCompactRouteLine(result.route);
+    }
+  } catch { /* enforcement is best-effort */ }
+
+  return [
+    "Avorelo Route",
+    `State: ${result.route.state}`,
+    `Inventory source: ${result.route.inventorySource || "cache"}`,
+    `Refresh level: ${result.route.refreshLevel || "cache"}`,
+    `Task type: ${result.taskContext.classification.taskType}`,
+    `Risk: ${result.taskContext.classification.risk}`,
+    `Chosen: ${result.route.chosenTool || "none"} / ${result.route.selectedModel || "unknown"} / ${result.route.chosenModelProfile || "unknown"}`,
+    `Fallback: ${result.route.fallbackTool || "none"} / ${result.route.fallbackModel || "unknown"} / ${result.route.fallbackModelProfile || "unknown"}`,
+    `Verify: ${(result.route.expectedVerification || []).join("; ") || "none"}`,
+    `Safety: ${(result.route.safetyNotes || []).join(" ") || "none"}`,
+  ].join("\n");
+}
+
+function renderRunCommand(cwd, args = []) {
+  const taskText = taskFromArgs(args);
+  if (!taskText) throw new Error("`avorelo run` requires a task.");
+
+  const prepareOnly = args.includes("--prepare-only") || args.includes("--no-execute");
+  const debug = args.includes("--debug");
+  const dryRun = args.includes("--dry-run");
+
+  try {
+    const { runSafeControlPipeline, formatSafeRunText } = require("../safe-run-controller");
+    const receipt = runSafeControlPipeline(cwd, taskText, {
+      prepareOnly,
+      dryRun,
+      surface: parseSurface(args),
+    });
+
+    if (wantsJson(args)) return JSON.stringify(receipt, null, 2);
+    return formatSafeRunText(receipt, { debug });
+  } catch (err) {
+    // Fallback to legacy run if safe-run-controller unavailable
+    try {
+      const result = runTask(cwd, taskText, {
+        surface: parseSurface(args),
+        dryRun,
+        refreshInventory: args.includes("--refresh"),
+      });
+      return wantsJson(args)
+        ? JSON.stringify({ runId: result.runId, route: result.route, execution: result.execution, verification: result.verification, proof: result.proof }, null, 2)
+        : [`Avorelo Run`, `Run: ${result.runId}`, `State: ${result.route.state}`, `Execution: ${result.execution.finalStatus}`].join("\n");
+    } catch (fallbackErr) {
+      throw new Error(`Safe run failed: ${err.message}`);
+    }
+  }
+}
+
+function renderModelsCommand(cwd, args = []) {
+  const inventory = loadInventory(cwd, { refresh: args.includes("--refresh"), deepRefresh: args.includes("--deep") });
+  return wantsJson(args) ? JSON.stringify(inventory, null, 2) : modelsText(cwd, { refresh: args.includes("--refresh"), deepRefresh: args.includes("--deep") });
+}
+
+function renderStatusCommand(cwd, args = []) {
+  const status = buildOrchestrationStatus(cwd, { refreshInventory: args.includes("--refresh"), deepRefresh: args.includes("--deep") });
+  const workerNotes = formatWorkerNotes(status.inventory);
+  return wantsJson(args)
+    ? JSON.stringify(status, null, 2)
+    : [
+        "Avorelo Orchestration Status",
+        status.statusLine,
+        `Inventory source: ${status.inventory.inventorySource || "cache"}`,
+        `Refresh level: ${status.inventory.refreshLevel || "cache"}`,
+        workerNotes ? `Worker notes: ${workerNotes}` : null,
+        status.currentRoute ? `Last route: ${status.currentRoute.selectedRoute}` : "Last route: none",
+        status.currentProof ? `Last proof: ${status.currentProof.finalStatus}` : "Last proof: none",
+      ].filter(Boolean).join("\n");
+}
+
+function renderProofCommand(cwd, args = []) {
+  const debug = args.includes("--debug") || args.includes("--verbose");
+  const subcommand = args.find((arg) => !String(arg).startsWith("-")) || null;
+  const proof = readCurrentProof(cwd);
+  const historyRequested = wantsHistory(args);
+  const exportRequested = wantsExport(args);
+  const jsonMode = wantsJson(args);
+
+  if (subcommand === "outcome" || subcommand === "readiness") {
+    const {
+      buildProofOutcomeEvidence,
+      writeProofOutcomeEvidence,
+      formatProofOutcomeEvidenceText,
+    } = require("../proof-outcome-evidence");
+    const evidence = buildProofOutcomeEvidence(cwd);
+    writeProofOutcomeEvidence(cwd, evidence);
+    return jsonMode ? JSON.stringify(evidence, null, 2) : formatProofOutcomeEvidenceText(evidence);
+  }
+
+  if (historyRequested && exportRequested) {
+    throw new Error("Use either --history or --export, not both.");
+  }
+
+  if (!historyRequested && !exportRequested) {
+    return jsonMode ? JSON.stringify(proof || {}, null, 2) : proofText(cwd, { debug });
+  }
+
+  const plan = getCurrentPlan({ cwd });
+  const baseText = proofText(cwd, { debug }).trimEnd();
+  const featureRequested = historyRequested ? "proof_history" : "proof_export";
+  const surfaceName = historyRequested ? "proof_history" : "proof_export";
+
+  if (plan === "pro") {
+    if (historyRequested) {
+      const history = readProofHistory(cwd, { plan });
+      if (jsonMode) {
+        return JSON.stringify({
+          proof: proof || {},
+          proofHistory: history.entries,
+          historyAvailable: history.available,
+          partial: history.partial,
+          sourcePath: history.sourcePath,
+          retention: history.retention,
+          redacted: true,
+        }, null, 2);
+      }
+      const sections = [baseText];
+      sections.push("");
+      sections.push(formatProofHistoryText(history));
+      return `${sections.filter(Boolean).join("\n")}\n`;
+    }
+
+    const exported = exportProofHistoryBundle(cwd, { plan });
+    if (jsonMode) {
+      return JSON.stringify({
+        proof: proof || {},
+        exported: exported.ok
+          ? {
+              jsonRel: exported.jsonRel,
+              mdRel: exported.mdRel,
+              count: exported.count,
+              partial: exported.partial,
+            }
+          : null,
+        proofHistory: exported.history?.entries || [],
+        exportAvailable: canExportReports(plan),
+        redacted: true,
+      }, null, 2);
+    }
+    const sections = [baseText];
+    sections.push("");
+    sections.push(
+      exported.ok
+        ? formatProofExportText(exported)
+        : "Proof export is not available yet.",
+    );
+    return `${sections.filter(Boolean).join("\n")}\n`;
+  }
+
+  const surface = buildProofDepthSurface(cwd, surfaceName, featureRequested);
+  const eventPayload = buildProofDepthPayload(surface);
+  appendProMomentEvent(cwd, "pro_feature_requested", eventPayload);
+  appendProMomentEvent(cwd, "pro_limit_reached", eventPayload);
+
+  if (jsonMode) {
+    recordProMomentEvaluation(cwd, surface, { humanVisible: false });
+    return JSON.stringify(
+      buildFreeProofDepthJson(proof, surface, {
+        requested: featureRequested,
+        historyAvailable: false,
+        exportAvailable: false,
+        redacted: true,
+      }),
+      null,
+      2,
+    );
+  }
+
+  recordProMomentEvaluation(cwd, surface, { humanVisible: true });
+  return renderFreeProofDepthText(baseText, surface);
+}
+
+function renderVerifyCommand(cwd, args = [], taskText = "") {
+  const taskContext = buildTaskContext(taskText || "Verify the current workspace deterministically.", {
+    surface: parseSurface(args),
+  });
+  const verification = verifyWorkspace(cwd, taskContext);
+  return wantsJson(args) ? JSON.stringify(verification, null, 2) : [
+    "Avorelo Verification",
+    `Status: ${verification.status}`,
+    `Why: ${verification.reason}`,
+    ...((verification.commands || []).map((entry) => `- ${entry.command} ${entry.args.join(" ")} -> ${entry.status}`)),
+  ].join("\n");
+}
+
+function renderSettingsCommand(cwd, args = []) {
+  const positional = args.filter((arg) => !arg.startsWith("--"));
+  const [verb, key, value] = positional;
+  if (!verb || verb === "show") {
+    const settings = getSettings(cwd);
+    const inventory = loadInventory(cwd, {});
+    return wantsJson(args)
+      ? JSON.stringify({ settings, inventory }, null, 2)
+      : formatSettingsText(settings, inventory);
+  }
+
+  if (verb === "set") {
+    if (key === "mode") {
+      const settings = setMode(cwd, value);
+      return wantsJson(args) ? JSON.stringify(settings, null, 2) : formatSettingsText(settings);
+    }
+    if (key === "ask-before-premium") {
+      const settings = setBooleanFlag(cwd, "askBeforePremium", parseBool(value));
+      return wantsJson(args) ? JSON.stringify(settings, null, 2) : formatSettingsText(settings);
+    }
+    if (key === "block-cheap-external-high-risk") {
+      const settings = setBooleanFlag(cwd, "blockCheapExternalHighRisk", parseBool(value));
+      return wantsJson(args) ? JSON.stringify(settings, null, 2) : formatSettingsText(settings);
+    }
+    if (key === "block-external-secrets") {
+      const settings = setBooleanFlag(cwd, "blockExternalSecrets", parseBool(value));
+      return wantsJson(args) ? JSON.stringify(settings, null, 2) : formatSettingsText(settings);
+    }
+    throw new Error(`Unsupported orchestration settings key: ${key}`);
+  }
+
+  if (verb === "enable-tool" || verb === "disable-tool") {
+    const settings = setWorkerEnabled(cwd, key, verb === "enable-tool");
+    return wantsJson(args) ? JSON.stringify(settings, null, 2) : formatSettingsText(settings);
+  }
+
+  throw new Error(`Unsupported orchestration settings action: ${verb}`);
+}
+
+function renderHandoffCommand(cwd, args = []) {
+  const positional = args.filter((arg) => !arg.startsWith("--"));
+  const toArg = args.find((a) => a.startsWith("--to=")) || args.find((a, i) => args[i - 1] === "--to");
+  const target = toArg ? (toArg.startsWith("--to=") ? toArg.split("=")[1] : args[args.indexOf("--to") + 1]) : "claude";
+  const taskArg = args.find((a) => a.startsWith("--task=")) || args.find((a, i) => args[i - 1] === "--task");
+  const taskText = taskArg ? (taskArg.startsWith("--task=") ? taskArg.slice(7) : args[args.indexOf("--task") + 1]) : positional[0] || "";
+
+  const result = generateHandoff(cwd, { target, taskText });
+
+  return wantsJson(args)
+    ? JSON.stringify(result.receipt, null, 2)
+    : [
+        `Avorelo Handoff`,
+        `ID: ${result.handoffId}`,
+        `Target: ${target}`,
+        `Prompt path: ${result.promptPath}`,
+        `Receipt path: ${result.receiptPath}`,
+        ``,
+        result.promptText,
+      ].join("\n");
+}
+
+function renderOrchestrationSurfaceCommand(cwd, args = []) {
+  const surface = buildAgentModelOrchestrationSurface(cwd);
+  return wantsJson(args)
+    ? JSON.stringify(surface, null, 2)
+    : [
+        `Agent Model Orchestration Surface`,
+        `Status: ${surface.status}`,
+        `Route state: ${surface.routeState || "none"}`,
+        `Selected worker: ${surface.selectedWorker || "none"}`,
+        `Fallback worker: ${surface.fallbackWorker || "none"}`,
+        `Stage count: ${surface.stageCount}`,
+        `Limited workers: ${surface.limitedWorkers}`,
+        `Local workers available: ${surface.localWorkersAvailable}`,
+        `Handoff available: ${surface.handoffAvailable}`,
+        `Next action: ${surface.nextAction}`,
+        `Foundation only: not a generic gateway`,
+      ].join("\n");
+}
+
+module.exports = {
+  renderRouteCommand,
+  renderRunCommand,
+  renderModelsCommand,
+  renderStatusCommand,
+  renderProofCommand,
+  renderVerifyCommand,
+  renderSettingsCommand,
+  renderHandoffCommand,
+  renderOrchestrationSurfaceCommand,
+};