orchestr8 2.1.3

package/src/init.js

@@ -0,0 +1,107 @@
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const TARGET_DIR = process.cwd();
+
+async function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase().trim());
+    });
+  });
+}
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function updateGitignore() {
+  const gitignorePath = path.join(TARGET_DIR, '.gitignore');
+  const entriesToAdd = [
+    '# agent-workflow',
+    '.claude/implement-queue.json'
+  ];
+
+  let content = '';
+  if (fs.existsSync(gitignorePath)) {
+    content = fs.readFileSync(gitignorePath, 'utf8');
+  }
+
+  const newEntries = entriesToAdd.filter(entry => !content.includes(entry));
+
+  if (newEntries.length > 0) {
+    const addition = '\n' + newEntries.join('\n') + '\n';
+    fs.appendFileSync(gitignorePath, addition);
+    console.log('Updated .gitignore');
+  }
+}
+
+async function init() {
+  const blueprintSrc = path.join(PACKAGE_ROOT, '.blueprint');
+  const blueprintDest = path.join(TARGET_DIR, '.blueprint');
+  const skillSrc = path.join(PACKAGE_ROOT, 'SKILL.md');
+  const skillDest = path.join(TARGET_DIR, 'SKILL.md');
+
+  // Check if .blueprint already exists
+  if (fs.existsSync(blueprintDest)) {
+    const answer = await prompt('.blueprint directory already exists. Overwrite? (y/N): ');
+    if (answer !== 'y' && answer !== 'yes') {
+      console.log('Aborted. Use "agent-workflow update" to update existing installation.');
+      return;
+    }
+    fs.rmSync(blueprintDest, { recursive: true });
+  }
+
+  // Check if SKILL.md already exists
+  if (fs.existsSync(skillDest)) {
+    const answer = await prompt('SKILL.md already exists. Overwrite? (y/N): ');
+    if (answer !== 'y' && answer !== 'yes') {
+      console.log('Skipping SKILL.md');
+    } else {
+      fs.copyFileSync(skillSrc, skillDest);
+      console.log('Copied SKILL.md');
+    }
+  } else {
+    fs.copyFileSync(skillSrc, skillDest);
+    console.log('Copied SKILL.md');
+  }
+
+  // Copy .blueprint directory
+  console.log('Copying .blueprint directory...');
+  copyDir(blueprintSrc, blueprintDest);
+  console.log('Copied .blueprint directory');
+
+  // Update .gitignore
+  updateGitignore();
+
+  console.log(`
+agent-workflow initialized successfully!
+
+Next steps:
+1. Add business context to .blueprint/.business_context/
+2. Run /implement-feature in Claude Code to start your first feature
+`);
+}
+
+module.exports = { init };

package/src/orchestrator.js

@@ -0,0 +1,217 @@
+const fs = require('fs');
+const path = require('path');
+
+const QUEUE_PATH = '.claude/implement-queue.json';
+
+function ensureQueueDir() {
+  const dir = path.dirname(QUEUE_PATH);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function createEmptyQueue() {
+  return {
+    lastUpdated: new Date().toISOString(),
+    current: null,
+    alexQueue: [],
+    cassQueue: [],
+    nigelQueue: [],
+    codeyQueue: [],
+    completed: [],
+    failed: []
+  };
+}
+
+function readQueue() {
+  ensureQueueDir();
+  if (!fs.existsSync(QUEUE_PATH)) {
+    const queue = createEmptyQueue();
+    writeQueue(queue);
+    return queue;
+  }
+  const content = fs.readFileSync(QUEUE_PATH, 'utf8');
+  return JSON.parse(content);
+}
+
+function writeQueue(queue) {
+  ensureQueueDir();
+  queue.lastUpdated = new Date().toISOString();
+  fs.writeFileSync(QUEUE_PATH, JSON.stringify(queue, null, 2));
+}
+
+function updateQueue(updates) {
+  const queue = readQueue();
+  Object.assign(queue, updates);
+  writeQueue(queue);
+  return queue;
+}
+
+function setCurrent(slug, stage) {
+  const queue = readQueue();
+  queue.current = {
+    slug,
+    stage,
+    startedAt: new Date().toISOString()
+  };
+  writeQueue(queue);
+  return queue;
+}
+
+function clearCurrent() {
+  const queue = readQueue();
+  queue.current = null;
+  writeQueue(queue);
+  return queue;
+}
+
+function moveToNextStage(slug, fromStage, toStage) {
+  const queue = readQueue();
+  const fromQueueName = `${fromStage}Queue`;
+  const toQueueName = `${toStage}Queue`;
+
+  // Remove from source queue
+  if (queue[fromQueueName]) {
+    queue[fromQueueName] = queue[fromQueueName].filter(item => item.slug !== slug);
+  }
+
+  // Add to destination queue
+  if (!queue[toQueueName]) {
+    queue[toQueueName] = [];
+  }
+
+  const entry = { slug, movedAt: new Date().toISOString() };
+  queue[toQueueName].push(entry);
+
+  // Update current stage
+  if (queue.current && queue.current.slug === slug) {
+    queue.current.stage = toStage;
+  }
+
+  writeQueue(queue);
+  return queue;
+}
+
+function markCompleted(slug, metadata = {}) {
+  const queue = readQueue();
+
+  // Remove from codeyQueue
+  queue.codeyQueue = queue.codeyQueue.filter(item => item.slug !== slug);
+
+  // Add to completed
+  queue.completed.push({
+    slug,
+    completedAt: new Date().toISOString(),
+    ...metadata
+  });
+
+  // Clear current if this was it
+  if (queue.current && queue.current.slug === slug) {
+    queue.current = null;
+  }
+
+  writeQueue(queue);
+  return queue;
+}
+
+function markFailed(slug, stage, reason) {
+  const queue = readQueue();
+
+  // Remove from all stage queues
+  ['alexQueue', 'cassQueue', 'nigelQueue', 'codeyQueue'].forEach(queueName => {
+    if (queue[queueName]) {
+      queue[queueName] = queue[queueName].filter(item => item.slug !== slug);
+    }
+  });
+
+  // Add to failed
+  queue.failed.push({
+    slug,
+    stage,
+    reason,
+    failedAt: new Date().toISOString()
+  });
+
+  // Clear current if this was it
+  if (queue.current && queue.current.slug === slug) {
+    queue.current = null;
+  }
+
+  writeQueue(queue);
+  return queue;
+}
+
+function resetQueue() {
+  const queue = createEmptyQueue();
+  writeQueue(queue);
+  return queue;
+}
+
+function getQueueStatus() {
+  const queue = readQueue();
+  return {
+    current: queue.current,
+    pending: {
+      alex: queue.alexQueue.length,
+      cass: queue.cassQueue.length,
+      nigel: queue.nigelQueue.length,
+      codey: queue.codeyQueue.length
+    },
+    completed: queue.completed.length,
+    failed: queue.failed.length
+  };
+}
+
+function displayQueue() {
+  const queue = readQueue();
+
+  console.log('\nImplement Feature Queue Status');
+  console.log('==============================\n');
+
+  if (queue.current) {
+    console.log('Current:');
+    console.log(`  ${queue.current.slug} (stage: ${queue.current.stage})`);
+    console.log(`  Started: ${queue.current.startedAt}\n`);
+  } else {
+    console.log('Current: (none)\n');
+  }
+
+  console.log('Queues:');
+  console.log(`  Alex:  ${queue.alexQueue.length} pending`);
+  console.log(`  Cass:  ${queue.cassQueue.length} pending`);
+  console.log(`  Nigel: ${queue.nigelQueue.length} pending`);
+  console.log(`  Codey: ${queue.codeyQueue.length} pending\n`);
+
+  if (queue.completed.length > 0) {
+    console.log('Completed:');
+    queue.completed.forEach(item => {
+      console.log(`  - ${item.slug} (${item.completedAt})`);
+    });
+    console.log('');
+  }
+
+  if (queue.failed.length > 0) {
+    console.log('Failed:');
+    queue.failed.forEach(item => {
+      console.log(`  - ${item.slug} at ${item.stage}: ${item.reason}`);
+    });
+    console.log('');
+  }
+
+  console.log(`Last updated: ${queue.lastUpdated}`);
+}
+
+module.exports = {
+  QUEUE_PATH,
+  readQueue,
+  writeQueue,
+  updateQueue,
+  setCurrent,
+  clearCurrent,
+  moveToNextStage,
+  markCompleted,
+  markFailed,
+  resetQueue,
+  getQueueStatus,
+  displayQueue
+};

package/src/skills.js

@@ -0,0 +1,93 @@
+const { execSync } = require('child_process');
+
+const AGENT_SKILLS = {
+  alex: {
+    name: 'Alex',
+    role: 'System Specification & Chief-of-Staff',
+    skills: [
+      { repo: 'https://github.com/waynesutton/convexskills', skill: 'avoid-feature-creep' },
+      { repo: 'https://github.com/pproenca/dot-skills', skill: 'feature-spec' }
+    ]
+  },
+  cass: {
+    name: 'Cass',
+    role: 'Story Writer / BA',
+    skills: [
+      { repo: 'https://github.com/aj-geddes/useful-ai-prompts', skill: 'user-story-writing' }
+    ]
+  },
+  nigel: {
+    name: 'Nigel',
+    role: 'Tester',
+    skills: [
+      { repo: 'https://github.com/wshobson/agents', skill: 'javascript-testing-patterns' },
+      { repo: 'https://github.com/wshobson/agents', skill: 'modern-javascript-patterns' }
+    ]
+  },
+  codey: {
+    name: 'Codey',
+    role: 'Developer',
+    skills: [
+      { repo: 'https://github.com/martinholovsky/claude-skills-generator', skill: 'javascript-expert' },
+      { repo: 'https://github.com/wshobson/agents', skill: 'modern-javascript-patterns' }
+    ]
+  }
+};
+
+function installSkill(repo, skill) {
+  const cmd = `npx skills add ${repo} --skill ${skill}`;
+  console.log(`  Running: ${cmd}`);
+  try {
+    execSync(cmd, { stdio: 'inherit' });
+    return true;
+  } catch (error) {
+    console.error(`  Failed to install ${skill}`);
+    return false;
+  }
+}
+
+async function addSkills(agent) {
+  const agents = agent === 'all' ? Object.keys(AGENT_SKILLS) : [agent.toLowerCase()];
+
+  for (const agentKey of agents) {
+    const agentConfig = AGENT_SKILLS[agentKey];
+
+    if (!agentConfig) {
+      console.error(`Unknown agent: ${agentKey}`);
+      console.error(`Available agents: ${Object.keys(AGENT_SKILLS).join(', ')}, all`);
+      process.exit(1);
+    }
+
+    console.log(`\nInstalling skills for ${agentConfig.name} (${agentConfig.role}):`);
+
+    for (const { repo, skill } of agentConfig.skills) {
+      installSkill(repo, skill);
+    }
+  }
+
+  console.log('\nSkills installation complete.');
+}
+
+function listSkills(agent) {
+  const agents = agent ? [agent.toLowerCase()] : Object.keys(AGENT_SKILLS);
+
+  console.log('\nAgent Workflow - Recommended Skills\n');
+
+  for (const agentKey of agents) {
+    const agentConfig = AGENT_SKILLS[agentKey];
+
+    if (!agentConfig) {
+      console.error(`Unknown agent: ${agentKey}`);
+      process.exit(1);
+    }
+
+    console.log(`${agentConfig.name} (${agentConfig.role}):`);
+    for (const { repo, skill } of agentConfig.skills) {
+      console.log(`  - ${skill}`);
+      console.log(`    ${repo}`);
+    }
+    console.log('');
+  }
+}
+
+module.exports = { addSkills, listSkills, AGENT_SKILLS };

package/src/update.js

@@ -0,0 +1,105 @@
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const TARGET_DIR = process.cwd();
+
+// Directories that contain user content and should NOT be overwritten
+const USER_CONTENT_DIRS = [
+  'features',
+  'system_specification',
+  '.business_context'
+];
+
+// Directories/files that should be updated
+const UPDATABLE = [
+  'agents',
+  'templates',
+  'ways_of_working'
+];
+
+async function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase().trim());
+    });
+  });
+}
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+async function update() {
+  const blueprintDest = path.join(TARGET_DIR, '.blueprint');
+  const blueprintSrc = path.join(PACKAGE_ROOT, '.blueprint');
+  const skillSrc = path.join(PACKAGE_ROOT, 'SKILL.md');
+  const skillDest = path.join(TARGET_DIR, 'SKILL.md');
+
+  // Check if .blueprint exists
+  if (!fs.existsSync(blueprintDest)) {
+    console.log('.blueprint directory not found. Run "agent-workflow init" first.');
+    process.exit(1);
+  }
+
+  console.log('Updating agent-workflow...');
+  console.log('(Preserving: features/, system_specification/, .business_context/)\n');
+
+  // Update each updatable directory
+  for (const dir of UPDATABLE) {
+    const srcDir = path.join(blueprintSrc, dir);
+    const destDir = path.join(blueprintDest, dir);
+
+    if (fs.existsSync(srcDir)) {
+      if (fs.existsSync(destDir)) {
+        fs.rmSync(destDir, { recursive: true });
+      }
+      copyDir(srcDir, destDir);
+      console.log(`Updated .blueprint/${dir}/`);
+    }
+  }
+
+  // Update SKILL.md
+  const answer = await prompt('\nUpdate SKILL.md? (Y/n): ');
+  if (answer !== 'n' && answer !== 'no') {
+    fs.copyFileSync(skillSrc, skillDest);
+    console.log('Updated SKILL.md');
+  }
+
+  console.log(`
+Update complete!
+
+Updated:
+  - .blueprint/agents/
+  - .blueprint/templates/
+  - .blueprint/ways_of_working/
+  - SKILL.md
+
+Preserved:
+  - .blueprint/features/
+  - .blueprint/system_specification/
+  - .blueprint/.business_context/
+`);
+}
+
+module.exports = { update };