jinzd-ai-cli 0.3.0 → 0.3.2

package/dist/hub-server-P547YWUN.js

@@ -0,0 +1,299 @@
+#!/usr/bin/env node
+import {
+  HubAgent,
+  assignRoleColors,
+  clearSpeakingLine,
+  renderAgentMessage,
+  renderAgentSpeaking,
+  renderConsensus,
+  renderHubBanner,
+  renderMaxRounds,
+  renderRoundHeader,
+  renderSummary,
+  renderUserInterrupt
+} from "./chunk-4ZAZF4CF.js";
+
+// src/hub/hub-server.ts
+import { WebSocketServer } from "ws";
+import { createServer } from "http";
+import chalk from "chalk";
+var HubServer = class {
+  constructor(config, providers, port) {
+    this.config = config;
+    this.providers = providers;
+    this.port = port;
+    this.unassignedRoles = [...config.roles];
+  }
+  wss = null;
+  httpServer = null;
+  agents = /* @__PURE__ */ new Map();
+  unassignedRoles = [];
+  history = [];
+  aborted = false;
+  currentTurnResolve = null;
+  /**
+   * Start the hub server and run the discussion.
+   */
+  async start(topic) {
+    assignRoleColors(this.config.roles);
+    this.httpServer = createServer();
+    this.wss = new WebSocketServer({ server: this.httpServer });
+    this.wss.on("connection", (ws) => this.handleConnection(ws));
+    await new Promise((resolve) => {
+      this.httpServer.listen(this.port, () => resolve());
+    });
+    const maxRounds = this.config.maxRounds ?? 10;
+    renderHubBanner(topic, this.config.roles, maxRounds);
+    console.log(chalk.bold.cyan(`  \u{1F310} Hub server listening on ws://localhost:${this.port}`));
+    console.log(chalk.dim(`  Waiting for ${this.config.roles.length} agent(s) to connect...`));
+    console.log(chalk.dim(`  Each agent should run: aicli join --port ${this.port}`));
+    console.log();
+    await this.waitForAgents(topic);
+    await this.runDiscussion(topic, maxRounds);
+    this.shutdown();
+  }
+  abort() {
+    this.aborted = true;
+    if (this.currentTurnResolve) {
+      this.currentTurnResolve({ content: "", passed: true });
+    }
+  }
+  shutdown() {
+    for (const agent of this.agents.values()) {
+      try {
+        agent.ws.close();
+      } catch {
+      }
+    }
+    this.wss?.close();
+    this.httpServer?.close();
+  }
+  // ── Connection Handling ──────────────────────────────────────────
+  handleConnection(ws) {
+    ws.on("message", (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        this.handleAgentMessage(ws, msg);
+      } catch {
+        this.sendTo(ws, { type: "error", message: "Invalid message format" });
+      }
+    });
+    ws.on("close", () => {
+      for (const [roleId, agent] of this.agents) {
+        if (agent.ws === ws) {
+          console.log(chalk.yellow(`  \u26A0 Agent "${agent.roleName}" (${roleId}) disconnected`));
+          this.agents.delete(roleId);
+          break;
+        }
+      }
+    });
+  }
+  handleAgentMessage(ws, msg) {
+    switch (msg.type) {
+      case "register": {
+        const requestedRole = msg.roleId;
+        const roleIndex = this.unassignedRoles.findIndex((r) => r.id === requestedRole);
+        if (roleIndex === -1) {
+          if (this.unassignedRoles.length === 0) {
+            this.sendTo(ws, { type: "error", message: "All roles are already assigned." });
+            ws.close();
+            return;
+          }
+          const role = requestedRole ? void 0 : this.unassignedRoles[0];
+          if (!role && requestedRole) {
+            const exists = this.config.roles.some((r) => r.id === requestedRole);
+            if (!exists) {
+              this.sendTo(ws, { type: "error", message: `Role "${requestedRole}" not found. Available: ${this.unassignedRoles.map((r) => r.id).join(", ")}` });
+              ws.close();
+              return;
+            }
+            this.sendTo(ws, { type: "error", message: `Role "${requestedRole}" is already taken. Available: ${this.unassignedRoles.map((r) => r.id).join(", ")}` });
+            ws.close();
+            return;
+          }
+          if (role) {
+            this.assignRole(ws, role);
+            this.unassignedRoles.splice(0, 1);
+          }
+        } else {
+          const role = this.unassignedRoles[roleIndex];
+          this.assignRole(ws, role);
+          this.unassignedRoles.splice(roleIndex, 1);
+        }
+        break;
+      }
+      case "response": {
+        if (this.currentTurnResolve) {
+          this.currentTurnResolve({ content: msg.content, passed: msg.passed });
+          this.currentTurnResolve = null;
+        }
+        break;
+      }
+    }
+  }
+  assignRole(ws, role) {
+    this.agents.set(role.id, {
+      ws,
+      roleId: role.id,
+      roleName: role.name,
+      ready: true
+    });
+    console.log(chalk.green(`  \u2713 Agent connected: ${role.name} (${role.id})`));
+    this.sendTo(ws, {
+      type: "welcome",
+      roleId: role.id,
+      roleName: role.name,
+      topic: "",
+      // Will be sent when discussion starts
+      roles: this.config.roles.map((r) => ({ id: r.id, name: r.name }))
+    });
+  }
+  // ── Wait for Agents ──────────────────────────────────────────────
+  async waitForAgents(topic) {
+    const totalRoles = this.config.roles.length;
+    const deadline = Date.now() + 12e4;
+    const checkInterval = 1e3;
+    while (this.unassignedRoles.length > 0 && Date.now() < deadline && !this.aborted) {
+      const connected = totalRoles - this.unassignedRoles.length;
+      process.stdout.write(`\r  Agents: ${connected}/${totalRoles} connected. Waiting... (${Math.ceil((deadline - Date.now()) / 1e3)}s remaining)  `);
+      await sleep(checkInterval);
+    }
+    process.stdout.write("\r\x1B[2K");
+    if (this.unassignedRoles.length > 0) {
+      console.log(chalk.dim(`  ${this.unassignedRoles.length} role(s) unfilled \u2014 using built-in AI agents:`));
+      for (const role of this.unassignedRoles) {
+        console.log(chalk.dim(`    \u2022 ${role.name} (${role.id}) \u2192 built-in`));
+      }
+      console.log();
+    }
+    for (const agent of this.agents.values()) {
+      this.sendTo(agent.ws, {
+        type: "welcome",
+        roleId: agent.roleId,
+        roleName: agent.roleName,
+        topic,
+        roles: this.config.roles.map((r) => ({ id: r.id, name: r.name }))
+      });
+    }
+  }
+  // ── Discussion Loop ──────────────────────────────────────────────
+  async runDiscussion(topic, maxRounds) {
+    for (let round = 1; round <= maxRounds; round++) {
+      if (this.aborted) {
+        renderUserInterrupt();
+        break;
+      }
+      renderRoundHeader(round, maxRounds);
+      this.broadcastAll({ type: "round_start", round, maxRounds });
+      let allPassed = true;
+      for (const role of this.config.roles) {
+        if (this.aborted) break;
+        renderAgentSpeaking(role.name, role.id);
+        let message;
+        const connectedAgent = this.agents.get(role.id);
+        if (connectedAgent) {
+          message = await this.getRemoteResponse(connectedAgent, role, topic, round, maxRounds);
+        } else {
+          message = await this.getBuiltinResponse(role, topic, round, maxRounds);
+        }
+        clearSpeakingLine();
+        this.history.push(message);
+        if (!message.passed) {
+          allPassed = false;
+        }
+        renderAgentMessage(message);
+        this.broadcastAll({ type: "agent_spoke", message: serializeMessage(message) });
+      }
+      if (allPassed && round > 1) {
+        renderConsensus();
+        this.broadcastAll({ type: "discussion_end", reason: "consensus" });
+        break;
+      }
+      if (round === maxRounds) {
+        renderMaxRounds(maxRounds);
+        this.broadcastAll({ type: "discussion_end", reason: "max_rounds" });
+      }
+    }
+    await this.generateSummary(topic);
+  }
+  async getRemoteResponse(agent, role, _topic, round, maxRounds) {
+    this.sendTo(agent.ws, {
+      type: "your_turn",
+      round,
+      maxRounds,
+      history: this.history.map(serializeMessage)
+    });
+    try {
+      const response = await Promise.race([
+        new Promise((resolve) => {
+          this.currentTurnResolve = resolve;
+        }),
+        sleep(12e4).then(() => ({ content: `[${role.name} timed out]`, passed: true }))
+      ]);
+      return {
+        speaker: role.id,
+        speakerName: role.name,
+        content: response.passed ? "" : response.content,
+        timestamp: /* @__PURE__ */ new Date(),
+        passed: response.passed
+      };
+    } catch {
+      return {
+        speaker: role.id,
+        speakerName: role.name,
+        content: "",
+        timestamp: /* @__PURE__ */ new Date(),
+        passed: true
+      };
+    }
+  }
+  async getBuiltinResponse(role, topic, round, maxRounds) {
+    const agent = new HubAgent(role, this.providers, this.config.defaultProvider, this.config.defaultModel);
+    return agent.speak(topic, this.history, round, maxRounds);
+  }
+  async generateSummary(topic) {
+    if (this.history.filter((m) => !m.passed && m.speaker !== "system").length === 0) {
+      return;
+    }
+    const summarizer = new HubAgent(
+      this.config.roles[0],
+      this.providers,
+      this.config.defaultProvider,
+      this.config.defaultModel
+    );
+    try {
+      console.log(chalk.dim("  Generating summary..."));
+      const summary = await summarizer.summarize(topic, this.history);
+      renderSummary(summary);
+      this.broadcastAll({ type: "discussion_end", reason: "max_rounds", summary });
+    } catch (err) {
+      console.log(chalk.red(`  Summary generation failed: ${err.message}`));
+    }
+  }
+  // ── Messaging ────────────────────────────────────────────────────
+  sendTo(ws, msg) {
+    if (ws.readyState === ws.OPEN) {
+      ws.send(JSON.stringify(msg));
+    }
+  }
+  broadcastAll(msg) {
+    const data = JSON.stringify(msg);
+    for (const agent of this.agents.values()) {
+      if (agent.ws.readyState === agent.ws.OPEN) {
+        agent.ws.send(data);
+      }
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function serializeMessage(msg) {
+  return {
+    ...msg,
+    timestamp: msg.timestamp instanceof Date ? msg.timestamp : new Date(msg.timestamp)
+  };
+}
+export {
+  HubServer
+};

package/dist/index.js

@@ -36,7 +36,7 @@ import {
   theme,
   truncateOutput,
   undoStack
-} from "./chunk-PTXAUPO2.js";
+} from "./chunk-GBP4DNBU.js";
 import {
   AGENTIC_BEHAVIOR_GUIDELINE,
   AUTHOR,
@@ -56,7 +56,7 @@ import {
   REPO_URL,
   SKILLS_DIR_NAME,
   VERSION
-} from "./chunk-TIGK5MRC.js";
+} from "./chunk-UEOKNL7V.js";
 
 // src/index.ts
 import { program } from "commander";
@@ -1907,7 +1907,7 @@ ${hint}` : "")
       description: "Run project tests and show structured report",
       usage: "/test [command|filter]",
       async execute(args, _ctx) {
-        const { executeTests } = await import("./run-tests-DI7E4ARF.js");
+        const { executeTests } = await import("./run-tests-6VOBLE77.js");
         const argStr = args.join(" ").trim();
         let testArgs = {};
         if (argStr) {
@@ -5517,7 +5517,7 @@ program.command("web").description("Start Web UI server with browser-based chat
     console.error("Error: Invalid port number. Must be between 1 and 65535.");
     process.exit(1);
   }
-  const { startWebServer } = await import("./server-HBM2BCSF.js");
+  const { startWebServer } = await import("./server-YFR3DO2P.js");
   await startWebServer({ port, host: options.host });
 });
 program.command("user [action] [username]").description("Manage Web UI users (list | create <name> | delete <name> | reset-password <name> | migrate <name>)").action(async (action, username) => {
@@ -5638,7 +5638,7 @@ program.command("sessions").description("List recent conversation sessions").act
   }
   console.log();
 });
-program.command("hub [topic]").description("Start multi-agent hub (discuss / brainstorm with multiple AI roles)").option("--preset <name>", "Use a built-in role preset (default: tech-review)").option("--roles <file>", "Load roles from a JSON file").option("--provider <name>", "Override default AI provider").option("-m, --model <name>", "Override default model").option("--max-rounds <n>", "Max discussion rounds (default: 10)").option("--presets", "List available role presets").action(async (topic, options) => {
+program.command("hub [topic]").description("Start multi-agent hub (discuss / brainstorm with multiple AI roles)").option("--preset <name>", "Use a built-in role preset (default: tech-review)").option("--roles <file>", "Load roles from a JSON file").option("--provider <name>", "Override default AI provider").option("-m, --model <name>", "Override default model").option("--max-rounds <n>", "Max discussion rounds (default: 10)").option("--presets", "List available role presets").option("--distributed", "Start WebSocket server so remote aicli instances can join as agents").option("--port <n>", "WebSocket port for distributed mode (default: 9527)", "9527").action(async (topic, options) => {
   const config = new ConfigManager();
   const registry = new ProviderRegistry();
   await registry.initialize(
@@ -5649,7 +5649,7 @@ program.command("hub [topic]").description("Start multi-agent hub (discuss / bra
     }),
     config.get("customProviders")
   );
-  const { startHub } = await import("./hub-72MJ7DED.js");
+  const { startHub } = await import("./hub-ZTEJJ4WD.js");
   await startHub(
     {
       topic: topic ?? "",
@@ -5658,7 +5658,33 @@ program.command("hub [topic]").description("Start multi-agent hub (discuss / bra
       provider: options.provider,
       model: options.model,
       maxRounds: options.maxRounds ? parseInt(options.maxRounds, 10) : void 0,
-      listPresets: options.presets === true
+      listPresets: options.presets === true,
+      distributed: options.distributed === true,
+      port: options.port ? parseInt(options.port, 10) : void 0
+    },
+    config,
+    registry
+  );
+});
+program.command("join").description("Join a running hub as a remote AI agent").option("--port <n>", "Hub WebSocket port (default: 9527)", "9527").option("--host <name>", "Hub host (default: localhost)", "localhost").option("--role <id>", "Request a specific role (e.g. architect, developer)").option("--provider <name>", "Override AI provider for this agent").option("-m, --model <name>", "Override model for this agent").action(async (options) => {
+  const config = new ConfigManager();
+  const registry = new ProviderRegistry();
+  await registry.initialize(
+    (id) => config.getApiKey(id),
+    (id) => ({
+      baseUrl: config.get("customBaseUrls")[id],
+      timeout: config.get("timeouts")[id]
+    }),
+    config.get("customProviders")
+  );
+  const { joinHub } = await import("./agent-client-OGXLZR5O.js");
+  await joinHub(
+    {
+      port: parseInt(options.port ?? "9527", 10),
+      host: options.host,
+      role: options.role,
+      provider: options.provider,
+      model: options.model
     },
     config,
     registry

package/dist/{run-tests-DI7E4ARF.js → run-tests-6VOBLE77.js}

@@ -2,7 +2,7 @@
 import {
   executeTests,
   runTestsTool
-} from "./chunk-TIGK5MRC.js";
+} from "./chunk-UEOKNL7V.js";
 export {
   executeTests,
   runTestsTool

package/dist/{run-tests-DEO6ATSG.js → run-tests-YDNIQ4L6.js}

@@ -1,7 +1,7 @@
 import {
   executeTests,
   runTestsTool
-} from "./chunk-TVODRYPD.js";
+} from "./chunk-AJ26XC7E.js";
 export {
   executeTests,
   runTestsTool

package/dist/{server-HBM2BCSF.js → server-YFR3DO2P.js}

@@ -27,7 +27,7 @@ import {
   spawnAgentContext,
   truncateOutput,
   undoStack
-} from "./chunk-PTXAUPO2.js";
+} from "./chunk-GBP4DNBU.js";
 import {
   AGENTIC_BEHAVIOR_GUIDELINE,
   CONTEXT_FILE_CANDIDATES,
@@ -39,7 +39,7 @@ import {
   PLAN_MODE_SYSTEM_ADDON,
   SKILLS_DIR_NAME,
   VERSION
-} from "./chunk-TIGK5MRC.js";
+} from "./chunk-UEOKNL7V.js";
 import {
   AuthManager
 } from "./chunk-CPLT6CD3.js";
@@ -1438,7 +1438,7 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
       case "test": {
         this.send({ type: "info", message: "\u{1F9EA} Running tests..." });
         try {
-          const { executeTests } = await import("./run-tests-DI7E4ARF.js");
+          const { executeTests } = await import("./run-tests-6VOBLE77.js");
           const argStr = args.join(" ").trim();
           let testArgs = {};
           if (argStr) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jinzd-ai-cli",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Cross-platform REPL-style AI CLI with multi-provider support",
   "type": "module",
   "main": "./dist/index.js",
@@ -56,6 +56,9 @@
     "dist/server-*.js",
     "dist/auth-*.js",
     "dist/run-tests-*.js",
+    "dist/hub-*.js",
+    "dist/hub-server-*.js",
+    "dist/agent-client-*.js",
     "dist/web/",
     "README.md"
   ],