agentxchain 0.7.2 → 0.8.0

package/bin/agentxchain.js

@@ -39,7 +39,7 @@ program
 program
   .command('start')
   .description('Launch agents in your IDE')
-  .option('--ide <ide>', 'Target IDE: vscode, claude-code', 'vscode')
+  .option('--ide <ide>', 'Target IDE: cursor, vscode, claude-code', 'cursor')
   .option('--agent <id>', 'Launch a specific agent only')
   .option('--dry-run', 'Print what would be launched without doing it')
   .action(startCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxchain",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "CLI for AgentXchain — multi-agent coordination in your IDE",
   "type": "module",
   "bin": {

package/src/adapters/cursor-local.js

@@ -0,0 +1,95 @@
+import { execSync } from 'child_process';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { generatePollingPrompt } from '../lib/seed-prompt-polling.js';
+
+export async function launchCursorLocal(config, root, opts) {
+  const agents = filterAgents(config, opts.agent);
+  const agentEntries = Object.entries(agents);
+  const total = agentEntries.length;
+
+  console.log(chalk.bold(`  Opening ${total} Cursor windows for: ${Object.keys(agents).join(', ')}`));
+  console.log('');
+
+  const promptDir = join(root, '.agentxchain-prompts');
+  try { execSync(`mkdir -p "${promptDir}"`); } catch {}
+
+  for (let i = 0; i < agentEntries.length; i++) {
+    const [id, agent] = agentEntries[i];
+    const prompt = generatePollingPrompt(id, agent, config);
+    const promptFile = join(promptDir, `${id}.prompt.md`);
+    writeFileSync(promptFile, prompt);
+
+    console.log(`  ${chalk.cyan(`Window ${i + 1}/${total}:`)} ${chalk.bold(id)} — ${agent.name}`);
+
+    copyToClipboard(prompt);
+    console.log(chalk.green(`    Prompt copied to clipboard.`));
+    console.log(chalk.dim(`    Also saved to: .agentxchain-prompts/${id}.prompt.md`));
+
+    tryOpenCursor(root);
+
+    if (i < agentEntries.length - 1) {
+      console.log('');
+      await inquirer.prompt([{
+        type: 'input',
+        name: 'ready',
+        message: chalk.dim(`    Paste prompt in Cursor chat (Cmd+V), send it, then press Enter here for the next agent...`)
+      }]);
+    } else {
+      console.log('');
+      console.log(chalk.dim(`    Paste this last prompt in Cursor chat (Cmd+V) and send it.`));
+    }
+  }
+
+  console.log('');
+  console.log(chalk.green('  All agent prompts ready.'));
+  console.log('');
+  console.log(`  ${chalk.cyan('Next:')}`);
+  console.log(`    ${chalk.bold('agentxchain release')}  ${chalk.dim('# release human lock — agents start claiming turns')}`);
+  console.log(`    ${chalk.bold('agentxchain watch')}    ${chalk.dim('# optional: TTL safety net + status logging')}`);
+  console.log(`    ${chalk.bold('agentxchain status')}   ${chalk.dim('# check who holds the lock')}`);
+  console.log(`    ${chalk.bold('agentxchain claim')}    ${chalk.dim('# pause agents and take control')}`);
+  console.log('');
+  console.log(chalk.dim('  Agents self-coordinate via lock.json polling (sleep 60s between checks).'));
+  console.log(chalk.dim('  Prompts saved in .agentxchain-prompts/ if you need to re-paste.'));
+  console.log('');
+}
+
+function filterAgents(config, specificId) {
+  if (specificId) {
+    if (!config.agents[specificId]) {
+      console.log(chalk.red(`  Agent "${specificId}" not found in agentxchain.json`));
+      process.exit(1);
+    }
+    return { [specificId]: config.agents[specificId] };
+  }
+  return config.agents;
+}
+
+function copyToClipboard(text) {
+  try {
+    if (process.platform === 'darwin') {
+      execSync('pbcopy', { input: text, encoding: 'utf8' });
+      return true;
+    }
+    if (process.platform === 'linux') {
+      execSync('xclip -selection clipboard', { input: text, encoding: 'utf8' });
+      return true;
+    }
+  } catch {}
+  return false;
+}
+
+function tryOpenCursor(root) {
+  try {
+    if (process.platform === 'darwin') {
+      execSync(`open -na "Cursor" --args "${root}"`, { stdio: 'ignore' });
+      return;
+    }
+    execSync(`cursor "${root}"`, { stdio: 'ignore' });
+  } catch {
+    // Cursor not found or can't open — user will open manually
+  }
+}

package/src/commands/init.js

@@ -207,7 +207,7 @@ export async function initCommand(opts) {
   writeFileSync(join(dir, 'log.md'), `# ${project} — Agent Log\n\n## COMPRESSED CONTEXT\n\n(No compressed context yet.)\n\n## MESSAGE LOG\n\n(Agents append messages below this line.)\n`);
   writeFileSync(join(dir, 'HUMAN_TASKS.md'), '# Human Tasks\n\n(Agents append tasks here when they need human action.)\n');
   const gitignorePath = join(dir, '.gitignore');
-  const requiredIgnores = ['.env', '.agentxchain-trigger.json'];
+  const requiredIgnores = ['.env', '.agentxchain-trigger.json', '.agentxchain-prompts/'];
   if (!existsSync(gitignorePath)) {
     writeFileSync(gitignorePath, requiredIgnores.join('\n') + '\n');
   } else {

package/src/commands/start.js

@@ -63,13 +63,18 @@ export async function startCommand(opts) {
       console.log('');
       break;
     }
+    case 'cursor': {
+      const { launchCursorLocal } = await import('../adapters/cursor-local.js');
+      await launchCursorLocal(config, root, opts);
+      break;
+    }
     case 'claude-code': {
       const { launchClaudeCodeAgents } = await import('../adapters/claude-code.js');
       await launchClaudeCodeAgents(config, root, opts);
       break;
     }
     default:
-      console.log(chalk.red(`  Unknown IDE: ${ide}. Supported: vscode, claude-code`));
+      console.log(chalk.red(`  Unknown IDE: ${ide}. Supported: vscode, cursor, claude-code`));
       process.exit(1);
   }
 }

package/src/lib/seed-prompt-polling.js

@@ -0,0 +1,128 @@
+export function generatePollingPrompt(agentId, agentDef, config) {
+  const logFile = config.log || 'log.md';
+  const maxClaims = config.rules?.max_consecutive_claims || 2;
+  const verifyCmd = config.rules?.verify_command || null;
+  const stateFile = config.state_file || 'state.md';
+  const historyFile = config.history_file || 'history.jsonl';
+  const useSplit = config.state_file || config.history_file;
+
+  const agentIds = Object.keys(config.agents);
+  const myIndex = agentIds.indexOf(agentId);
+  const prevAgent = myIndex === 0 ? null : agentIds[myIndex - 1];
+  const isFirstAgent = myIndex === 0;
+
+  const turnCondition = isFirstAgent
+    ? `It is YOUR turn when lock.json shows holder=null AND (last_released_by is null, "human", "system", OR the LAST agent in the rotation: "${agentIds[agentIds.length - 1]}")`
+    : `It is YOUR turn when lock.json shows holder=null AND last_released_by="${prevAgent}"`;
+
+  const readSection = useSplit
+    ? `READ THESE FILES:
+- "${stateFile}" — the living project state. Read fully. Primary context.
+- "${historyFile}" — turn history. Read last 3 lines for recent context.
+- lock.json — who holds the lock.
+- state.json — phase and blocked status.`
+    : `READ THESE FILES:
+- "${logFile}" — the message log. Read last few messages.
+- lock.json — who holds the lock.
+- state.json — phase and blocked status.`;
+
+  const writeSection = useSplit
+    ? `WRITE (in this order):
+a. Do your actual work: write code, create files, run commands, make decisions.
+b. Update "${stateFile}" — OVERWRITE with current project state.
+c. Append ONE line to "${historyFile}":
+   {"turn": N, "agent": "${agentId}", "summary": "what you did", "files_changed": [...], "verify_result": "pass|fail|skipped", "timestamp": "ISO8601"}
+d. Update state.json if phase or blocked status changed.`
+    : `WRITE (in this order):
+a. Do your actual work: write code, create files, run commands, make decisions.
+b. Append ONE message to ${logFile}:
+   ---
+   ### [${agentId}] (${agentDef.name}) | Turn N
+   **Status:** Current project state.
+   **Decision:** What you decided and why.
+   **Action:** What you did. Commands, files, results.
+   **Next:** What the next agent should focus on.
+c. Update state.json if phase or blocked status changed.`;
+
+  const verifySection = verifyCmd
+    ? `
+VERIFY (mandatory before release):
+Run: ${verifyCmd}
+If it FAILS: fix the problem. Run again. Do NOT release with failing verification.
+If it PASSES: report the result. Then release.`
+    : '';
+
+  return `You are "${agentId}" — ${agentDef.name}.
+
+${agentDef.mandate}
+
+---
+
+PROJECT DOCUMENTATION (.planning/ folder):
+
+These files give you project context. Read the ones relevant to your role.
+
+- .planning/PROJECT.md — Vision, constraints, stack decisions. PM writes this.
+- .planning/REQUIREMENTS.md — Scoped requirements with acceptance criteria. PM writes this.
+- .planning/ROADMAP.md — Phased delivery plan. PM maintains this.
+- .planning/research/ — Domain research, prior art, technical investigation.
+- .planning/phases/ — Per-phase plans (PLAN.md), reviews (REVIEW.md), test results (TESTS.md), bugs (BUGS.md).
+- .planning/qa/TEST-COVERAGE.md — Which features are tested and how. QA maintains this.
+- .planning/qa/BUGS.md — Open and fixed bugs with reproduction steps. QA maintains this.
+- .planning/qa/UX-AUDIT.md — UX checklist and visual/usability issues. QA maintains this.
+- .planning/qa/ACCEPTANCE-MATRIX.md — Requirements mapped to test status. QA maintains this.
+- .planning/qa/REGRESSION-LOG.md — Fixed bugs and their regression tests.
+
+When your role requires it, CREATE or UPDATE these files.
+
+---
+
+TEAM ROTATION: ${agentIds.join(' → ')} → (repeat)
+YOUR POSITION: ${agentId} (index ${myIndex} of ${agentIds.length})
+${turnCondition}
+
+---
+
+YOUR LOOP (run forever, never exit, never say "I'm done"):
+
+1. READ lock.json.
+
+2. CHECK — is it my turn?
+   - If holder is NOT null → someone else is working. Run the shell command: sleep 60
+     Then go back to step 1.
+   - If holder IS null → check last_released_by:
+     ${isFirstAgent
+       ? `- If last_released_by is null, "human", starts with "system", or "${agentIds[agentIds.length - 1]}" → IT IS YOUR TURN. Go to step 3.`
+       : `- If last_released_by is "${prevAgent}" → IT IS YOUR TURN. Go to step 3.`}
+     - Otherwise → it is another agent's turn. Run the shell command: sleep 60
+       Then go back to step 1.
+
+3. CLAIM the lock:
+   Write lock.json: {"holder":"${agentId}","last_released_by":<keep previous>,"turn_number":<keep previous>,"claimed_at":"<current ISO timestamp>"}
+   Then RE-READ lock.json immediately. If holder is not "${agentId}", someone else won. Go to step 1.
+
+4. DO YOUR WORK:
+   ${readSection}
+
+   THINK: What did the previous agent do? What is most important for YOUR role? What is one risk?
+
+   ${writeSection}${verifySection}
+
+5. RELEASE the lock:
+   Write lock.json: {"holder":null,"last_released_by":"${agentId}","turn_number":<previous + 1>,"claimed_at":null}
+   THIS MUST BE THE LAST FILE YOU WRITE.
+
+6. Run the shell command: sleep 60
+   Then go back to step 1.
+
+---
+
+CRITICAL RULES:
+- ACTUALLY RUN "sleep 60" in the terminal between checks. Do NOT skip this. Do NOT just say "waiting."
+- Never write files or code without holding the lock. Reading is always allowed.
+- One git commit per turn: "Turn N - ${agentId} - description"
+- Max ${maxClaims} consecutive turns. If you have held the lock ${maxClaims} times in a row, do a short turn and release.
+- ALWAYS release the lock. A stuck lock blocks the entire team.
+- ALWAYS find at least one problem, risk, or question about the previous work. Blind agreement is forbidden.
+- NEVER exit or stop. After releasing, always sleep and poll again. You are a persistent agent.`;
+}