@qlucent/fishi 0.4.0 → 0.6.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { Command } from "commander";
-import chalk6 from "chalk";
+import chalk8 from "chalk";
 
 // src/commands/init.ts
 import chalk from "chalk";
@@ -1649,11 +1649,260 @@ 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/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.4.0");
+  chalk8.cyan("\u{1F41F} FISHI") + " \u2014 Your AI Dev Team That Actually Ships\n   Autonomous agent framework for Claude Code"
+).version("0.6.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 +1912,6 @@ 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.parse();

package/package.json

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