@kendoo.agentdesk/agentdesk 0.2.0 → 0.3.0

package/cli/agents.mjs

@@ -0,0 +1,267 @@
+// Agent registry — defines all built-in agents and generates prompt sections
+
+export const BUILT_IN_AGENTS = {
+  Jane: {
+    badge: "●● JANE ●●",
+    role: "Product Analyst / Team Lead",
+    description: "facilitates discussion, clarifies requirements, keeps the team focused, evaluates team performance at the end",
+    groundRules: "Jane resolves disagreements and keeps the discussion productive. She NEVER reads code, runs tools, or inspects files — that's the developer and auditor's job. She focuses on requirements, user impact, scope, and coordination.",
+    brainstorm: { tag: "SAY", focus: "facilitation, question, or summary" },
+    planning: "Requirements Summary (what we're building, acceptance criteria, scope boundaries)",
+    execution: {
+      step: "Jane wraps up",
+      tasks: [
+        "Review the PR description. Ensure it explains what changed and why.",
+        "Summarize the session.",
+      ],
+      order: 99, // last
+    },
+  },
+  Dennis: {
+    badge: "■■ DENNIS ■■",
+    role: "Senior Developer",
+    description: "assesses technical feasibility, proposes architecture, implements the solution",
+    groundRules: "Dennis must verify at least 1 assumption about the codebase before agreeing to any approach.",
+    codePrinciple: "Never write logic inline inside components or UI templates. Extract all conditionals, transformations, calculations, and API calls into dedicated functions, hooks, or services.",
+    brainstorm: { tag: "THINK", focus: "technical feasibility, existing patterns" },
+    planning: "Implementation Plan (files to modify, approach, complexity S/M/L)",
+    execution: {
+      step: "Dennis implements",
+      tasks: [
+        "Create a branch following project conventions.",
+        "Implement the changes according to the agreed plan.",
+        "Run linter and build to verify.",
+        "Commit the implementation.",
+      ],
+      order: 1,
+    },
+  },
+  Sam: {
+    badge: "◆◆ SAM ◆◆",
+    role: "Architecture Auditor",
+    description: "scans for separation-of-concerns violations, guards code architecture",
+    groundRules: "Sam must verify that the proposed approach does not introduce architecture violations. He always backs claims with a file reference or line number.",
+    codePrinciple: "Actively guards separation of concerns throughout the session. Always cites file and line number.",
+    brainstorm: { tag: "THINK", focus: "codebase patterns, architecture risks" },
+    planning: "Architecture Review (existing violations, whether approach is clean)",
+    execution: {
+      step: "Sam scans for violations",
+      tasks: [
+        "Read all files the developer changed.",
+        "Check for architecture violations.",
+        "If violations found, the developer fixes them before proceeding.",
+      ],
+      order: 2,
+    },
+  },
+  Bart: {
+    badge: "▲▲ BART ▲▲",
+    role: "QA Engineer",
+    description: "identifies edge cases, test plans, acceptance criteria, quality risks",
+    groundRules: "Bart must identify at least 2 risks or edge cases before agreeing to any plan.",
+    codePrinciple: "Flag any logic written directly inside a component or UI template.",
+    brainstorm: { tag: "SAY", focus: "risks, edge cases, \"what happens when...\"" },
+    planning: "Test Plan (acceptance criteria, key test cases, edge cases)",
+    execution: {
+      step: "Bart reviews",
+      tasks: [
+        "Read EVERY file the developer changed.",
+        "Check calculations, edge cases, error handling.",
+        "Run linter and build.",
+        "If ALL criteria pass, push and create PR: `gh pr create --title \"...\" --body \"...\"`",
+        "Approve the PR if clean.",
+      ],
+      order: 4,
+    },
+  },
+  Vera: {
+    badge: "◈◈ VERA ◈◈",
+    role: "Test Engineer",
+    description: "writes unit and regression tests for changed code, ensures test coverage",
+    groundRules: "Vera must identify which functions need unit test coverage before agreeing to any plan.",
+    codePrinciple: "Never mount or render UI to test a logic outcome. Test files must mirror the service/utility structure.",
+    brainstorm: { tag: "SAY", focus: "test coverage gaps, which functions need tests" },
+    planning: "Test Plan (which functions need tests, regression tests)",
+    execution: {
+      step: "Vera writes tests",
+      tasks: [
+        "Read every file the developer changed. Identify testable functions.",
+        "Write unit tests following existing test patterns.",
+        "Run tests to verify they pass.",
+        "Commit test files.",
+      ],
+      order: 3,
+    },
+  },
+  Luna: {
+    badge: "☾☾ LUNA ☾☾",
+    role: "UX/UI Designer",
+    description: "designs pixel-perfect interfaces, champions user experience, applies psychology of user behavior, ensures visual consistency, accessibility, and intuitive interaction patterns",
+    groundRules: "Luna must review any UI changes for visual consistency, spacing, color harmony, accessibility (contrast, focus states), and intuitive interaction flow. She references specific components, screenshots, or design patterns.",
+    codePrinciple: "Reviews all UI changes for visual hierarchy, whitespace balance, color consistency, typography, responsive behavior, and accessibility (WCAG). Pushes back on cluttered layouts, inconsistent spacing, poor contrast, or confusing interaction flows. Proposes specific CSS/styling improvements with exact values.",
+    brainstorm: { tag: "THINK", focus: "UX/UI impact, visual consistency, interaction patterns, accessibility" },
+    planning: "UX Review (visual impact, layout concerns, accessibility checklist, interaction improvements)",
+    execution: {
+      step: "Luna reviews UI changes (if applicable)",
+      tasks: [
+        "Read any changed component, page, or style files.",
+        "Check visual hierarchy, spacing consistency, color harmony, typography.",
+        "Verify accessibility: contrast ratios, focus states, keyboard navigation, screen reader labels.",
+        "Check responsive behavior and interaction flow.",
+        "If issues found, propose specific fixes (exact CSS values, spacing, colors). The developer implements them before proceeding.",
+        "Skip this step if the task has no UI impact.",
+      ],
+      order: 2.1,
+    },
+  },
+  Mark: {
+    badge: "✦✦ MARK ✦✦",
+    role: "Content Writer",
+    description: "crafts precise, engaging copy for UI text, error messages, tooltips, onboarding flows, and documentation. Simplifies technical language into friendly, clear wording. Ensures consistent tone and voice across the product",
+    groundRules: "Mark must review all user-facing text — labels, buttons, headings, error messages, tooltips, empty states, confirmation dialogs. He ensures the tone is friendly and consistent, wording is concise, and technical jargon is avoided unless the audience is technical.",
+    codePrinciple: "Reviews all user-facing strings in changed files. Rewrites vague, wordy, or technical copy into clear, concise, human-friendly language. Ensures consistent voice — no mixing formal and casual tone. Checks empty states, error messages, and confirmation dialogs for helpfulness.",
+    brainstorm: { tag: "THINK", focus: "copy clarity, tone, user-facing text quality" },
+    planning: "Content Review (user-facing text audit, tone, clarity, empty states, error messages)",
+    execution: {
+      step: "Mark reviews content (if applicable)",
+      tasks: [
+        "Read all changed files that contain user-facing text (components, templates, error handlers).",
+        "Check every label, button, heading, tooltip, error message, empty state, and confirmation dialog.",
+        "Rewrite anything vague, wordy, jargon-heavy, or inconsistent in tone.",
+        "Propose exact replacement strings. The developer implements them.",
+        "Skip this step if the task has no user-facing text changes.",
+      ],
+      order: 2.2,
+    },
+  },
+};
+
+/**
+ * Resolve the team from config.
+ * - If config.team is an array of names, use those built-in agents in that order.
+ * - If config.team contains objects, treat as custom agents.
+ * - Jane is always included (she's the lead).
+ * - Dennis is always included (someone has to implement).
+ */
+export function resolveTeam(config) {
+  const teamConfig = config.team || null;
+
+  // Default: all 7 agents
+  if (!teamConfig) {
+    return Object.entries(BUILT_IN_AGENTS).map(([name, agent]) => ({ name, ...agent }));
+  }
+
+  const team = [];
+  for (const entry of teamConfig) {
+    if (typeof entry === "string") {
+      // Built-in agent by name
+      const agent = BUILT_IN_AGENTS[entry];
+      if (agent) {
+        team.push({ name: entry, ...agent });
+      } else {
+        console.warn(`Warning: Unknown agent "${entry}" — skipping`);
+      }
+    } else if (typeof entry === "object" && entry.name) {
+      // Custom agent
+      const builtin = BUILT_IN_AGENTS[entry.name];
+      if (builtin) {
+        // Override a built-in agent's role
+        team.push({ ...builtin, name: entry.name, ...entry, badge: builtin.badge });
+      } else {
+        // Fully custom agent
+        team.push({
+          name: entry.name,
+          badge: entry.badge || `** ${entry.name.toUpperCase()} **`,
+          role: entry.role || "Team Member",
+          description: entry.description || entry.role || "Custom team member",
+          groundRules: entry.groundRules || "",
+          brainstorm: entry.brainstorm || { tag: "SAY", focus: entry.role || "general input" },
+          planning: entry.planning || `${entry.role || entry.name} Review`,
+          execution: entry.execution || null,
+        });
+      }
+    }
+  }
+
+  // Ensure Jane and Dennis are always present
+  if (!team.find(a => a.name === "Jane")) {
+    team.unshift({ name: "Jane", ...BUILT_IN_AGENTS.Jane });
+  }
+  if (!team.find(a => a.name === "Dennis")) {
+    const jane = team.findIndex(a => a.name === "Jane");
+    team.splice(jane + 1, 0, { name: "Dennis", ...BUILT_IN_AGENTS.Dennis });
+  }
+
+  return team;
+}
+
+/**
+ * Generate the dynamic parts of the prompt from the team.
+ */
+export function generateTeamPrompt(team) {
+  const count = team.length;
+  const agentWord = count === 1 ? "one AI agent" : `${count} AI agents`;
+
+  const sections = {};
+
+  // Agent list
+  sections.agentList = team.map(a =>
+    `- ${a.name} (${a.role}) — ${a.description}`
+  ).join("\n");
+
+  // Speaking order
+  sections.speakingOrder = team.map((a, i) =>
+    `${i + 1}. ${a.badge}`
+  ).join("\n");
+
+  // Ground rules
+  const rules = [];
+  rules.push(`1. Each agent speaks in turn, prefixed with their badge (e.g., "${team[0].badge} Starting.").`);
+  rules.push(`2. ALL text output MUST be prefixed with the acting agent's badge. Never output unprefixed text.`);
+  rules.push(`3. Agents should DISAGREE when they see problems — don't rubber-stamp each other.`);
+  let ruleNum = 4;
+  for (const a of team) {
+    if (a.groundRules) {
+      rules.push(`${ruleNum}. ${a.groundRules}`);
+      ruleNum++;
+    }
+  }
+  rules.push(`${ruleNum}. Every statement should add value — no filler, no repeating what someone else already said.`);
+  sections.groundRules = rules.join("\n");
+
+  // Code principles
+  const principles = team
+    .filter(a => a.codePrinciple)
+    .map(a => `- ${a.name}: ${a.codePrinciple}`);
+  sections.codePrinciples = principles.length > 0 ? principles.join("\n") : "";
+
+  // Brainstorm order
+  sections.brainstormOrder = team.map((a, i) =>
+    `${i + 1}. ${a.badge}  [${a.brainstorm.tag}]  ${a.brainstorm.focus}`
+  ).join("\n");
+
+  // Planning presentations
+  sections.planningOrder = team.map(a =>
+    `${a.badge}  ${a.planning}`
+  ).join("\n");
+
+  // Execution steps
+  const execAgents = team
+    .filter(a => a.execution)
+    .sort((a, b) => a.execution.order - b.execution.order);
+  let stepNum = 1;
+  const execSteps = [];
+  for (const a of execAgents) {
+    const tasks = a.execution.tasks.map((t, i) => `${i + 1}. ${t}`).join("\n");
+    execSteps.push(`### Step ${stepNum} — ${a.name} ${a.execution.step.replace(/^[A-Za-z]+ /, "")}:\n${tasks}`);
+    stepNum++;
+  }
+  sections.executionSteps = execSteps.join("\n\n");
+
+  // Count and phrasing
+  sections.count = count;
+  sections.agentWord = agentWord;
+  sections.names = team.map(a => a.name);
+
+  return sections;
+}

package/cli/config.mjs

@@ -21,14 +21,12 @@ const DEFAULTS = {
     repo: null,     // e.g., "owner/repo" — auto-detected from git if null
   },
 
-  // Agent customization
-  agents: {
-    Jane:   { role: "Product Analyst / Team Lead" },
-    Dennis: { role: "Senior Developer" },
-    Bart:   { role: "QA Engineer" },
-    Vera:   { role: "Test Engineer" },
-    Sam:    { role: "Architecture Auditor" },
-  },
+  // Team composition — array of agent names or custom agent objects
+  // Default: all 7 agents. To customize:
+  //   "team": ["Jane", "Dennis", "Sam", "Bart"]  — 4-agent team (no Luna, Mark, Vera)
+  //   "team": ["Jane", "Dennis", "Sam", {"name": "Alex", "role": "DevOps Engineer", "description": "..."}]
+  // Jane and Dennis are always included even if omitted.
+  team: null,
 
   // Commands — auto-detected if null
   commands: {

package/cli/team.mjs

@@ -10,6 +10,7 @@ import WebSocket from "ws";
 import { detectProject, generateContext } from "./detect.mjs";
 import { loadConfig } from "./config.mjs";
 import { getStoredApiKey } from "./login.mjs";
+import { resolveTeam, generateTeamPrompt } from "./agents.mjs";
 
 function loadDotEnv(dir) {
   const envPath = join(dir, ".env");
@@ -153,7 +154,18 @@ export async function runTeam(taskId, opts = {}) {
       }
     });
     vizWs.on("error", () => { vizConnected = false; });
-    vizWs.on("close", () => { vizConnected = false; });
+    vizWs.on("close", (code) => {
+      vizConnected = false;
+      if (code === 1006 && !vizConnected) {
+        console.log("AgentDesk: not connected — run 'agentdesk login' to authenticate");
+      }
+    });
+    vizWs.on("unexpected-response", (_req, res) => {
+      if (res.statusCode === 401) {
+        console.log("AgentDesk: authentication required — run 'agentdesk login'");
+      }
+      vizConnected = false;
+    });
   } catch {
     // AgentDesk not running
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kendoo.agentdesk/agentdesk",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "AI team orchestrator for Claude Code — run collaborative agent sessions from your terminal",
   "type": "module",
   "bin": {
@@ -24,25 +24,22 @@
     "test": "node --test tests/server.test.mjs"
   },
   "dependencies": {
+    "bcryptjs": "^3.0.3",
+    "express": "^5.1.0",
+    "jsonwebtoken": "^9.0.3",
+    "sql.js": "^1.14.1",
     "ws": "^8.18.0"
   },
   "devDependencies": {
-    "@logto/react": "^4.0.13",
     "@vitejs/plugin-react": "^4.5.2",
     "autoprefixer": "^10.4.21",
-    "bcryptjs": "^3.0.3",
     "concurrently": "^9.2.0",
-    "express": "^5.1.0",
-    "jose": "^6.2.2",
-    "jsonwebtoken": "^9.0.3",
     "lucide-react": "^0.577.0",
     "postcss": "^8.5.4",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
-    "sql.js": "^1.14.1",
     "tailwindcss": "^3.4.17",
-    "vite": "^6.3.5",
-    "ws": "^8.18.0"
+    "vite": "^6.3.5"
   },
   "keywords": [
     "ai",