@qlucent/fishi 0.5.0 → 0.7.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { Command } from "commander";
-import chalk6 from "chalk";
+import chalk9 from "chalk";
 
 // src/commands/init.ts
 import chalk from "chalk";
@@ -10,7 +10,7 @@ import ora from "ora";
 import inquirer from "inquirer";
 import path3 from "path";
 import fs3 from "fs";
-import { detectConflicts, createBackup } from "@qlucent/fishi-core";
+import { detectConflicts, createBackup, detectDocker } from "@qlucent/fishi-core";
 
 // src/analyzers/detector.ts
 import fs from "fs";
@@ -1005,6 +1005,23 @@ async function initCommand(description, options) {
   } else {
     initOptions = await runWizard(options);
   }
+  const dockerAvailable = detectDocker();
+  let sandboxMode = "process";
+  if (options.interactive !== false) {
+    if (dockerAvailable) {
+      const { useSandbox } = await inquirer.prompt([{
+        type: "confirm",
+        name: "useSandbox",
+        message: "Docker detected. Use Docker sandbox for agent isolation? (Recommended)",
+        default: true
+      }]);
+      sandboxMode = useSandbox ? "docker" : "process";
+    } else {
+      console.log(chalk.yellow("  Docker not found. Using process-level sandbox (limited isolation)."));
+      console.log(chalk.gray("  Install Docker for full agent isolation: https://docs.docker.com/get-docker/"));
+      console.log("");
+    }
+  }
   let brownfieldAnalysis = null;
   if (detection.type === "brownfield" || detection.type === "hybrid") {
     console.log("");
@@ -1148,6 +1165,21 @@ async function initCommand(description, options) {
       const report = generateBrownfieldReport(brownfieldAnalysis);
       fs3.writeFileSync(reportPath, report, "utf-8");
     }
+    const sandboxYaml = `
+sandbox:
+  mode: ${sandboxMode}
+  docker_available: ${dockerAvailable}
+`;
+    const fishiYamlPath = path3.join(targetDir, ".fishi", "fishi.yaml");
+    if (fs3.existsSync(fishiYamlPath)) {
+      fs3.appendFileSync(fishiYamlPath, sandboxYaml, "utf-8");
+    }
+    const { getSandboxPolicyTemplate, getDockerfileTemplate } = await import("@qlucent/fishi-core");
+    fs3.writeFileSync(path3.join(targetDir, ".fishi", "sandbox-policy.yaml"), getSandboxPolicyTemplate(), "utf-8");
+    if (sandboxMode === "docker") {
+      fs3.mkdirSync(path3.join(targetDir, ".fishi", "docker"), { recursive: true });
+      fs3.writeFileSync(path3.join(targetDir, ".fishi", "docker", "Dockerfile"), getDockerfileTemplate(), "utf-8");
+    }
     scaffoldSpinner.succeed("FISHI framework scaffolded successfully!");
     console.log("");
     console.log(chalk.bold("  Created:"));
@@ -1158,6 +1190,7 @@ async function initCommand(description, options) {
     console.log(chalk.gray(`  \u{1F4C4} .claude/CLAUDE.md       \u2014 Project instructions`));
     console.log(chalk.gray(`  \u{1F4C4} .claude/settings.json   \u2014 Hooks & permissions`));
     console.log(chalk.gray(`  \u{1F4C4} .mcp.json               \u2014 MCP server config`));
+    console.log(chalk.gray(`  \u{1F512} Sandbox:              ${sandboxMode} mode${sandboxMode === "docker" ? " (full isolation)" : " (limited isolation)"}`));
     if (brownfieldAnalysis) {
       console.log(chalk.gray(`  \u{1F4C4} .fishi/memory/brownfield-analysis.md \u2014 Codebase analysis report`));
       console.log("");
@@ -1649,11 +1682,299 @@ async function validateCommand() {
   }
 }
 
+// src/commands/monitor.ts
+import chalk6 from "chalk";
+import fs8 from "fs";
+import path8 from "path";
+import { parse as parseYaml4 } from "yaml";
+import { readMonitorState, getAgentSummary } from "@qlucent/fishi-core";
+var PHASES = ["init", "discovery", "planning", "development", "testing", "review", "deployed"];
+function formatNumber(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return String(n);
+}
+function renderPhaseBar(currentPhase) {
+  const idx = PHASES.indexOf(currentPhase);
+  const parts = PHASES.map((p, i) => {
+    if (i < idx) return chalk6.green(`[${p}]`);
+    if (i === idx) return chalk6.cyan.bold(`[${p}]`);
+    return chalk6.gray(`[${p}]`);
+  });
+  return "  " + parts.join(chalk6.gray(" \u2192 "));
+}
+function renderDivider(label) {
+  const line = "\u2500".repeat(60);
+  return chalk6.gray(`
+  ${line}
+  `) + chalk6.bold(label) + "\n";
+}
+function renderMonitor(projectDir) {
+  const state = readMonitorState(projectDir);
+  const agentSummary = getAgentSummary(projectDir);
+  let currentPhase = "init";
+  const projectYamlPath = path8.join(projectDir, ".fishi", "state", "project.yaml");
+  if (fs8.existsSync(projectYamlPath)) {
+    try {
+      const projectState = parseYaml4(fs8.readFileSync(projectYamlPath, "utf-8"));
+      currentPhase = projectState?.current_phase || "init";
+    } catch {
+    }
+  }
+  let gates = [];
+  const gatesYamlPath = path8.join(projectDir, ".fishi", "state", "gates.yaml");
+  if (fs8.existsSync(gatesYamlPath)) {
+    try {
+      const gatesData = parseYaml4(fs8.readFileSync(gatesYamlPath, "utf-8"));
+      gates = gatesData?.gates || [];
+    } catch {
+    }
+  }
+  const { summary, dynamicAgents, events, lastUpdated } = state;
+  console.log("");
+  console.log(chalk6.cyan.bold("  FISHI Agent Monitor"));
+  console.log(chalk6.gray(`  Last updated: ${new Date(lastUpdated).toLocaleTimeString()}`));
+  console.log(renderDivider("Phase Progress"));
+  console.log(renderPhaseBar(currentPhase));
+  console.log("");
+  console.log(renderDivider("Summary"));
+  console.log(
+    `  ${chalk6.bold("Completions:")} ${chalk6.cyan(summary.totalAgentCompletions)}   ${chalk6.bold("Files Changed:")} ${chalk6.cyan(summary.totalFilesChanged)}   ${chalk6.bold("Tokens:")} ${chalk6.cyan(formatNumber(summary.totalTokens))}   ${chalk6.bold("Dynamic Agents:")} ${chalk6.cyan(summary.dynamicAgentsCreated)}`
+  );
+  console.log(renderDivider("Tokens by Model"));
+  const modelEntries = Object.entries(summary.tokensByModel);
+  if (modelEntries.length === 0) {
+    console.log(chalk6.gray("  (none yet)"));
+  } else {
+    for (const [model, tokens] of modelEntries.sort((a, b) => b[1] - a[1])) {
+      console.log(`  ${chalk6.yellow(model.padEnd(30))} ${chalk6.cyan(formatNumber(tokens))}`);
+    }
+  }
+  console.log(renderDivider("Tools Used"));
+  const toolEntries = Object.entries(summary.toolsUsed);
+  if (toolEntries.length === 0) {
+    console.log(chalk6.gray("  (none yet)"));
+  } else {
+    for (const [tool, count] of toolEntries.sort((a, b) => b[1] - a[1]).slice(0, 10)) {
+      console.log(`  ${chalk6.yellow(tool.padEnd(30))} ${chalk6.cyan(count)}`);
+    }
+  }
+  console.log(renderDivider("Agent Activity"));
+  const agentEntries = Object.entries(agentSummary);
+  if (agentEntries.length === 0) {
+    console.log(chalk6.gray("  (no agent events yet)"));
+  } else {
+    for (const [agent, stats] of agentEntries.sort((a, b) => b[1].completions - a[1].completions)) {
+      const failColor = stats.failures > 0 ? chalk6.red : chalk6.gray;
+      console.log(
+        `  ${chalk6.magenta(agent.padEnd(28))}  completions: ${chalk6.cyan(stats.completions)}  failures: ${failColor(stats.failures)}  files: ${chalk6.cyan(stats.filesChanged)}`
+      );
+    }
+  }
+  if (dynamicAgents.length > 0) {
+    console.log(renderDivider("Dynamic Agents"));
+    for (const da of dynamicAgents) {
+      console.log(`  ${chalk6.magenta(da.name)}  ${chalk6.gray("\u2190")} ${chalk6.gray(da.coordinator)}`);
+    }
+  }
+  if (gates.length > 0) {
+    console.log(renderDivider("Gates"));
+    for (const gate of gates) {
+      const statusColor = gate.status === "passed" ? chalk6.green : gate.status === "failed" ? chalk6.red : chalk6.yellow;
+      console.log(`  ${statusColor("\u25CF")} ${gate.name.padEnd(30)} ${statusColor(gate.status)}`);
+    }
+  }
+  console.log(renderDivider("Recent Events (last 10)"));
+  const recentEvents = events.slice(-10).reverse();
+  if (recentEvents.length === 0) {
+    console.log(chalk6.gray("  (no events yet)"));
+  } else {
+    for (const ev of recentEvents) {
+      const ts = new Date(ev.timestamp).toLocaleTimeString();
+      console.log(
+        `  ${chalk6.gray(ts)}  ${chalk6.cyan(ev.type.padEnd(20))}  ${chalk6.magenta(ev.agent)}`
+      );
+    }
+  }
+  console.log("");
+}
+async function monitorCommand(options) {
+  const projectDir = process.cwd();
+  const fishiDir = path8.join(projectDir, ".fishi");
+  if (!fs8.existsSync(fishiDir)) {
+    console.log(chalk6.yellow("\n  FISHI is not initialized in this directory."));
+    console.log(chalk6.gray("  Run `fishi init` to get started.\n"));
+    return;
+  }
+  if (!options.watch) {
+    renderMonitor(projectDir);
+    return;
+  }
+  const monitorJsonPath = path8.join(fishiDir, "state", "monitor.json");
+  let lastMtime = 0;
+  const render = () => {
+    process.stdout.write("\x1B[2J\x1B[0;0H");
+    renderMonitor(projectDir);
+    console.log(chalk6.gray("  [watch mode \u2014 polling every 1s, Ctrl+C to exit]"));
+  };
+  render();
+  const interval = setInterval(() => {
+    try {
+      if (fs8.existsSync(monitorJsonPath)) {
+        const mtime = fs8.statSync(monitorJsonPath).mtimeMs;
+        if (mtime !== lastMtime) {
+          lastMtime = mtime;
+          render();
+        }
+      }
+    } catch {
+    }
+  }, 1e3);
+  process.on("SIGINT", () => {
+    clearInterval(interval);
+    console.log(chalk6.gray("\n  Monitor exited.\n"));
+    process.exit(0);
+  });
+}
+
+// src/commands/dashboard.ts
+import http from "http";
+import fs9 from "fs";
+import path9 from "path";
+import { parse as parseYaml5 } from "yaml";
+import chalk7 from "chalk";
+import { readMonitorState as readMonitorState2, getAgentSummary as getAgentSummary2, getDashboardHtml } from "@qlucent/fishi-core";
+var DEFAULT_PORT = 4269;
+async function dashboardCommand(options) {
+  const projectDir = process.cwd();
+  const fishiDir = path9.join(projectDir, ".fishi");
+  if (!fs9.existsSync(fishiDir)) {
+    console.log(chalk7.yellow("\n  FISHI is not initialized in this directory."));
+    console.log(chalk7.gray("  Run `fishi init` to get started.\n"));
+    return;
+  }
+  const port = Number(options.port || DEFAULT_PORT);
+  if (isNaN(port) || port < 1 || port > 65535) {
+    console.error(chalk7.red(`  Invalid port: ${options.port}`));
+    process.exit(1);
+  }
+  const html = getDashboardHtml();
+  const server = http.createServer((req, res) => {
+    const url = req.url?.split("?")[0] ?? "/";
+    if (url === "/") {
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(html);
+      return;
+    }
+    if (url === "/api/state") {
+      try {
+        const monitorState = readMonitorState2(projectDir);
+        const agentSummary = getAgentSummary2(projectDir);
+        let phase = "init";
+        const projectYamlPath = path9.join(fishiDir, "state", "project.yaml");
+        if (fs9.existsSync(projectYamlPath)) {
+          try {
+            const projectState = parseYaml5(fs9.readFileSync(projectYamlPath, "utf-8"));
+            phase = projectState?.current_phase || "init";
+          } catch {
+          }
+        }
+        let gates = [];
+        const gatesYamlPath = path9.join(fishiDir, "state", "gates.yaml");
+        if (fs9.existsSync(gatesYamlPath)) {
+          try {
+            const gatesData = parseYaml5(fs9.readFileSync(gatesYamlPath, "utf-8"));
+            gates = gatesData?.gates || [];
+          } catch {
+          }
+        }
+        const payload = {
+          summary: monitorState.summary,
+          events: monitorState.events,
+          dynamicAgents: monitorState.dynamicAgents,
+          lastUpdated: monitorState.lastUpdated,
+          agentSummary,
+          phase,
+          gates
+        };
+        res.writeHead(200, {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*"
+        });
+        res.end(JSON.stringify(payload));
+      } catch (err) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: String(err) }));
+      }
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("Not found");
+  });
+  server.listen(port, () => {
+    console.log("");
+    console.log(chalk7.cyan.bold("  FISHI Agent Dashboard"));
+    console.log("");
+    console.log(`  ${chalk7.bold("URL:")}  ${chalk7.cyan(`http://localhost:${port}`)}`);
+    console.log(`  ${chalk7.bold("API:")}  ${chalk7.gray(`http://localhost:${port}/api/state`)}`);
+    console.log("");
+    console.log(chalk7.gray("  Press Ctrl+C to stop.\n"));
+  });
+  process.on("SIGINT", () => {
+    server.close(() => {
+      console.log(chalk7.gray("\n  Dashboard stopped.\n"));
+      process.exit(0);
+    });
+  });
+  await new Promise((resolve) => {
+    server.on("close", resolve);
+  });
+}
+
+// src/commands/sandbox.ts
+import chalk8 from "chalk";
+import fs10 from "fs";
+import path10 from "path";
+import { detectDocker as detectDocker2, readSandboxConfig, readSandboxPolicy } from "@qlucent/fishi-core";
+async function sandboxCommand(action) {
+  const targetDir = process.cwd();
+  if (!fs10.existsSync(path10.join(targetDir, ".fishi"))) {
+    console.log(chalk8.yellow("  No FISHI project found. Run `fishi init` first."));
+    return;
+  }
+  if (action === "status") {
+    const config = readSandboxConfig(targetDir);
+    const dockerNow = detectDocker2();
+    console.log("");
+    console.log(chalk8.cyan.bold("  FISHI Sandbox Status"));
+    console.log("");
+    console.log(chalk8.white("  Mode:             ") + (config.mode === "docker" ? chalk8.green("Docker") : chalk8.yellow("Process")));
+    console.log(chalk8.white("  Docker available:  ") + (dockerNow ? chalk8.green("yes") : chalk8.red("no")));
+    if (config.mode === "docker" && !dockerNow) {
+      console.log(chalk8.red("  Warning: Docker mode configured but Docker not available!"));
+    }
+    console.log("");
+    const policy = readSandboxPolicy(targetDir);
+    console.log(chalk8.white.bold("  Policy"));
+    console.log(chalk8.gray(`    Timeout:         ${policy.timeout}s`));
+    console.log(chalk8.gray(`    Memory limit:    ${policy.memory}`));
+    console.log(chalk8.gray(`    CPU limit:       ${policy.cpus}`));
+    console.log(chalk8.gray(`    Network allow:   ${policy.networkAllow.join(", ")}`));
+    console.log(chalk8.gray(`    Env passthrough: ${policy.envPassthrough.length > 0 ? policy.envPassthrough.join(", ") : "(none)"}`));
+    console.log("");
+  } else if (action === "policy") {
+    const policy = readSandboxPolicy(targetDir);
+    console.log(JSON.stringify(policy, null, 2));
+  } else {
+    console.log(chalk8.yellow(`  Unknown action: ${action}. Use: status, policy`));
+  }
+}
+
 // src/index.ts
 var program = new Command();
 program.name("fishi").description(
-  chalk6.cyan("\u{1F41F} FISHI") + " \u2014 Your AI Dev Team That Actually Ships\n   Autonomous agent framework for Claude Code"
-).version("0.5.0");
+  chalk9.cyan("\u{1F41F} FISHI") + " \u2014 Your AI Dev Team That Actually Ships\n   Autonomous agent framework for Claude Code"
+).version("0.7.0");
 program.command("init").description("Initialize FISHI in the current directory").argument("[description]", "Project description (skip wizard with zero-config)").option("-l, --language <lang>", "Primary language (e.g., typescript, python)").option("-f, --framework <framework>", "Framework (e.g., nextjs, express, django)").option(
   "-c, --cost-mode <mode>",
   "Cost mode: performance | balanced | economy",
@@ -1663,4 +1984,7 @@ program.command("status").description("Show project status, active agents, and T
 program.command("mcp").description("Manage MCP server integrations").argument("<action>", "Action: add | list | remove").argument("[name]", "MCP server name").action(mcpCommand);
 program.command("reset").description("Rollback to a previous checkpoint").argument("[checkpoint]", "Checkpoint ID (defaults to latest)").action(resetCommand);
 program.command("validate").description("Validate scaffold integrity \u2014 checks files, frontmatter, cross-references, pipeline, and permissions").action(validateCommand);
+program.command("monitor").description("Agent observability \u2014 TUI dashboard showing agent activity, tokens, gates").option("-w, --watch", "Watch mode \u2014 auto-refresh on changes").action(monitorCommand);
+program.command("dashboard").description("Agent observability \u2014 web dashboard at http://localhost:4269").option("-p, --port <port>", "Port number", "4269").action(dashboardCommand);
+program.command("sandbox").description("Sandbox status and policy management").argument("<action>", "Action: status | policy").action(sandboxCommand);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qlucent/fishi",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "FISHI — Your AI Dev Team That Actually Ships. Autonomous agent framework for Claude Code.",
   "license": "MIT",
   "type": "module",