@agentic15.com/agentic15-claude-zen 1.1.0 → 2.0.1

package/bin/agentic15.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { AuthCommand } from '../src/cli/AuthCommand.js';
+import { TaskCommand } from '../src/cli/TaskCommand.js';
+import { CommitCommand } from '../src/cli/CommitCommand.js';
+import { StatusCommand } from '../src/cli/StatusCommand.js';
+import { PlanCommand } from '../src/cli/PlanCommand.js';
+
+const program = new Command();
+
+program
+  .name('agentic15')
+  .description('Agentic15 Claude Zen - Automated AI development workflow')
+  .version('2.0.0');
+
+// GitHub authentication setup
+program
+  .command('auth')
+  .description('GitHub authentication setup')
+  .action(() => AuthCommand.setup());
+
+// Task management
+program
+  .command('task')
+  .description('Task management')
+  .argument('<action>', 'Action: start, next, status')
+  .argument('[taskId]', 'Task ID (e.g., TASK-001) - required for "start"')
+  .action((action, taskId) => TaskCommand.handle(action, taskId));
+
+// Auto-commit workflow
+program
+  .command('commit')
+  .description('Run tests, commit, push, create PR')
+  .action(() => CommitCommand.execute());
+
+// Show status
+program
+  .command('status')
+  .description('Show current task status and progress')
+  .action(() => StatusCommand.show());
+
+// Plan management (single command for generate + lock)
+program
+  .command('plan')
+  .description('Generate and lock plan')
+  .argument('[description]', 'Project description (required for first run)')
+  .action((description) => PlanCommand.handle(description));
+
+program.parse();

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@agentic15.com/agentic15-claude-zen",
-  "version": "1.1.0",
+  "version": "2.0.1",
   "description": "Structured AI-assisted development framework for Claude Code with enforced quality standards",
   "main": "dist/index.js",
   "bin": {
-    "agentic15-claude-zen": "./bin/create-agentic15-claude-zen.js"
+    "agentic15-claude-zen": "./bin/create-agentic15-claude-zen.js",
+    "agentic15": "./bin/agentic15.js"
   },
   "type": "module",
   "scripts": {
@@ -54,7 +55,8 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@octokit/rest": "^20.0.2"
+    "@octokit/rest": "^20.0.2",
+    "commander": "^12.1.0"
   },
   "devDependencies": {
     "@playwright/test": "^1.57.0",

package/src/cli/AuthCommand.js

@@ -0,0 +1,195 @@
+import { execSync } from 'child_process';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import readline from 'readline';
+import { Octokit } from '@octokit/rest';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export class AuthCommand {
+  static async setup() {
+    console.log('\n🔐 GitHub Authentication Setup\n');
+
+    // Step 1: Display current git configuration
+    this.displayGitConfig();
+
+    // Step 2: Confirm configuration
+    const configOk = await this.confirmConfig();
+    if (!configOk) {
+      this.showConfigCommands();
+      console.log('\n❌ Setup cancelled. Please configure git first.\n');
+      process.exit(1);
+    }
+
+    // Step 3: Get GitHub token
+    const token = await this.promptToken();
+
+    // Step 4: Validate token
+    const isValid = await this.validateToken(token);
+    if (!isValid) {
+      console.log('\n❌ Invalid GitHub token. Please try again.\n');
+      process.exit(1);
+    }
+
+    // Step 5: Auto-detect owner/repo
+    const { owner, repo } = this.detectRepo();
+
+    // Step 6: Save configuration
+    this.saveConfig(token, owner, repo);
+
+    console.log('\n✅ GitHub authentication configured successfully!\n');
+    console.log(`   Owner: ${owner}`);
+    console.log(`   Repo: ${repo}`);
+    console.log(`   Config: .claude/settings.local.json\n`);
+  }
+
+  static displayGitConfig() {
+    console.log('📋 Current Git Configuration:\n');
+
+    try {
+      // Global config
+      const globalName = execSync('git config --global user.name', { encoding: 'utf-8' }).trim();
+      const globalEmail = execSync('git config --global user.email', { encoding: 'utf-8' }).trim();
+
+      console.log('   Global:');
+      console.log(`   - user.name:  ${globalName || '(not set)'}`);
+      console.log(`   - user.email: ${globalEmail || '(not set)'}`);
+
+      // Local config (project-specific)
+      try {
+        const localName = execSync('git config --local user.name', { encoding: 'utf-8' }).trim();
+        const localEmail = execSync('git config --local user.email', { encoding: 'utf-8' }).trim();
+
+        if (localName || localEmail) {
+          console.log('\n   Local (this project):');
+          console.log(`   - user.name:  ${localName || '(not set)'}`);
+          console.log(`   - user.email: ${localEmail || '(not set)'}`);
+        }
+      } catch (e) {
+        // No local config, that's ok
+      }
+
+      console.log('');
+    } catch (error) {
+      console.log('   ⚠️  Unable to read git config. Is git installed?\n');
+    }
+  }
+
+  static showConfigCommands() {
+    console.log('\n💡 To configure git, use these commands:\n');
+    console.log('   Global (all projects):');
+    console.log('   git config --global user.name "Your Name"');
+    console.log('   git config --global user.email "your@email.com"\n');
+    console.log('   Local (this project only):');
+    console.log('   git config --local user.name "Your Name"');
+    console.log('   git config --local user.email "your@email.com"\n');
+  }
+
+  static async confirmConfig() {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    return new Promise((resolve) => {
+      rl.question('Is this configuration correct? (y/n): ', (answer) => {
+        rl.close();
+        resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+      });
+    });
+  }
+
+  static async promptToken() {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    console.log('🔑 GitHub Personal Access Token:');
+    console.log('   Create one at: https://github.com/settings/tokens');
+    console.log('   Required scopes: repo (Full control of private repositories)\n');
+
+    return new Promise((resolve) => {
+      rl.question('Enter your GitHub token: ', (token) => {
+        rl.close();
+        resolve(token.trim());
+      });
+    });
+  }
+
+  static async validateToken(token) {
+    try {
+      const octokit = new Octokit({ auth: token });
+      await octokit.rest.users.getAuthenticated();
+      console.log('\n✓ Token validated successfully');
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  static detectRepo() {
+    try {
+      // Get remote URL
+      const remoteUrl = execSync('git config --get remote.origin.url', { encoding: 'utf-8' }).trim();
+
+      // Parse owner/repo from URL
+      // Handles: git@github.com:owner/repo.git or https://github.com/owner/repo.git
+      const match = remoteUrl.match(/github\.com[:/]([^/]+)\/(.+?)(\.git)?$/);
+
+      if (match) {
+        return {
+          owner: match[1],
+          repo: match[2]
+        };
+      }
+    } catch (error) {
+      // Fallback if no remote
+    }
+
+    // Fallback: prompt user
+    console.log('\n⚠️  Could not auto-detect repository from git remote.');
+    console.log('   Using placeholder values. Update .claude/settings.local.json manually.\n');
+
+    return {
+      owner: 'your-github-username',
+      repo: 'your-repo-name'
+    };
+  }
+
+  static saveConfig(token, owner, repo) {
+    const settingsPath = join(process.cwd(), '.claude', 'settings.local.json');
+    const settingsDir = dirname(settingsPath);
+
+    // Ensure directory exists
+    if (!existsSync(settingsDir)) {
+      mkdirSync(settingsDir, { recursive: true });
+    }
+
+    // Read existing settings or create new
+    let settings = {};
+    if (existsSync(settingsPath)) {
+      try {
+        settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+      } catch (e) {
+        // Invalid JSON, start fresh
+      }
+    }
+
+    // Update GitHub config
+    settings.github = {
+      enabled: true,
+      autoCreate: true,
+      autoUpdate: true,
+      autoClose: true,
+      token,
+      owner,
+      repo
+    };
+
+    // Write settings
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  }
+}

package/src/cli/CommitCommand.js

@@ -0,0 +1,290 @@
+import { execSync } from 'child_process';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { GitHubClient } from '../core/GitHubClient.js';
+import { GitHubConfig } from '../core/GitHubConfig.js';
+
+export class CommitCommand {
+  static async execute() {
+    console.log('\n🚀 Starting commit workflow...\n');
+
+    // Step 1: Find active task
+    const { task, tracker } = this.getActiveTask();
+
+    if (!task) {
+      console.log('❌ No task in progress');
+      console.log('   Start a task first: agentic15 task start TASK-001\n');
+      process.exit(1);
+    }
+
+    console.log(`📌 Task: ${task.id} - ${task.title}\n`);
+
+    // Step 2: Run tests
+    console.log('🧪 Running tests...\n');
+    this.runTests();
+
+    // Step 3: Stage files in Agent/
+    console.log('\n📦 Staging changes...\n');
+    this.stageFiles();
+
+    // Step 4: Generate commit message
+    const commitMessage = this.generateCommitMessage(task);
+
+    // Step 5: Commit
+    console.log('💾 Creating commit...\n');
+    this.createCommit(commitMessage);
+
+    // Step 6: Push to feature branch
+    console.log('⬆️  Pushing to remote...\n');
+    this.pushBranch(task.id);
+
+    // Step 7: Create PR
+    console.log('🔀 Creating pull request...\n');
+    const prUrl = await this.createPullRequest(task, commitMessage);
+
+    // Step 8: Update GitHub issue status
+    await this.updateGitHubIssue(task, prUrl);
+
+    // Step 9: Display summary
+    this.displaySummary(task, prUrl, tracker);
+  }
+
+  static getActiveTask() {
+    const activePlanPath = join(process.cwd(), '.claude', 'ACTIVE-PLAN');
+
+    if (!existsSync(activePlanPath)) {
+      console.log('\n❌ No active plan found\n');
+      process.exit(1);
+    }
+
+    const planId = readFileSync(activePlanPath, 'utf-8').trim();
+    const trackerPath = join(process.cwd(), '.claude', 'plans', planId, 'TASK-TRACKER.json');
+
+    if (!existsSync(trackerPath)) {
+      console.log('\n❌ Task tracker not found\n');
+      process.exit(1);
+    }
+
+    const tracker = JSON.parse(readFileSync(trackerPath, 'utf-8'));
+    const task = tracker.taskFiles.find(t => t.status === 'in_progress');
+
+    return { task, tracker };
+  }
+
+  static runTests() {
+    try {
+      execSync('npm test', { stdio: 'inherit' });
+      console.log('\n✅ All tests passed');
+    } catch (error) {
+      console.log('\n❌ Tests failed. Fix errors before committing.\n');
+      process.exit(1);
+    }
+  }
+
+  static stageFiles() {
+    try {
+      // Stage all files in Agent/
+      execSync('git add Agent/', { stdio: 'inherit' });
+
+      // Also stage scripts/ if exists
+      try {
+        execSync('git add scripts/', { stdio: 'pipe' });
+      } catch (e) {
+        // scripts/ might not exist
+      }
+
+      // Show what was staged
+      const staged = execSync('git diff --cached --name-only', { encoding: 'utf-8' });
+
+      if (!staged.trim()) {
+        console.log('⚠️  No changes to commit\n');
+        process.exit(0);
+      }
+
+      console.log('Staged files:');
+      staged.trim().split('\n').forEach(file => {
+        console.log(`   ✓ ${file}`);
+      });
+    } catch (error) {
+      console.log(`\n❌ Failed to stage files: ${error.message}\n`);
+      process.exit(1);
+    }
+  }
+
+  static generateCommitMessage(task) {
+    // Load full task details
+    const activePlanPath = join(process.cwd(), '.claude', 'ACTIVE-PLAN');
+    const planId = readFileSync(activePlanPath, 'utf-8').trim();
+    const taskPath = join(process.cwd(), '.claude', 'plans', planId, 'tasks', `${task.id}.json`);
+
+    let taskData;
+    try {
+      taskData = JSON.parse(readFileSync(taskPath, 'utf-8'));
+    } catch (e) {
+      taskData = task;
+    }
+
+    // Format: [TASK-001] Task title
+    return `[${task.id}] ${taskData.title || task.title}`;
+  }
+
+  static createCommit(message) {
+    try {
+      // Escape double quotes and backslashes for shell
+      const escapedMessage = message.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+      execSync(`git commit -m "${escapedMessage}"`, { stdio: 'inherit' });
+      console.log('✅ Commit created');
+    } catch (error) {
+      console.log(`\n❌ Failed to create commit: ${error.message}\n`);
+      process.exit(1);
+    }
+  }
+
+  static pushBranch(taskId) {
+    const branchName = `feature/${taskId.toLowerCase()}`;
+
+    try {
+      // Check if branch has upstream
+      try {
+        execSync('git rev-parse --abbrev-ref --symbolic-full-name @{u}', { stdio: 'pipe' });
+        // Has upstream, just push
+        execSync('git push', { stdio: 'inherit' });
+      } catch (e) {
+        // No upstream, set it
+        execSync(`git push -u origin ${branchName}`, { stdio: 'inherit' });
+      }
+
+      console.log('✅ Pushed to remote');
+    } catch (error) {
+      console.log(`\n❌ Failed to push: ${error.message}\n`);
+      process.exit(1);
+    }
+  }
+
+  static async createPullRequest(task, commitMessage) {
+    try {
+      // Get main branch name
+      const mainBranch = this.getMainBranch();
+
+      // Load task for issue number
+      const activePlanPath = join(process.cwd(), '.claude', 'ACTIVE-PLAN');
+      const planId = readFileSync(activePlanPath, 'utf-8').trim();
+      const taskPath = join(process.cwd(), '.claude', 'plans', planId, 'tasks', `${task.id}.json`);
+
+      let taskData;
+      try {
+        taskData = JSON.parse(readFileSync(taskPath, 'utf-8'));
+      } catch (e) {
+        taskData = task;
+      }
+
+      // Build PR body
+      let prBody = taskData.description || '';
+
+      if (taskData.githubIssue) {
+        prBody += `\n\nCloses #${taskData.githubIssue}`;
+      }
+
+      // Create PR using gh CLI
+      const prCommand = `gh pr create --title "${commitMessage}" --body "${prBody}" --base ${mainBranch}`;
+      const prOutput = execSync(prCommand, { encoding: 'utf-8' });
+
+      // Extract PR URL from output
+      const prUrl = prOutput.match(/https:\/\/github\.com\/[^\s]+/)?.[0];
+
+      if (prUrl) {
+        console.log(`✅ Pull request created: ${prUrl}`);
+        return prUrl;
+      }
+
+      console.log('✅ Pull request created');
+      return null;
+    } catch (error) {
+      console.log(`\n⚠️  Failed to create PR: ${error.message}`);
+      console.log('   You may need to install GitHub CLI: https://cli.github.com/\n');
+      return null;
+    }
+  }
+
+  static async updateGitHubIssue(task, prUrl) {
+    const config = new GitHubConfig(process.cwd());
+
+    if (!config.isAutoUpdateEnabled()) {
+      return;
+    }
+
+    try {
+      // Load task data
+      const activePlanPath = join(process.cwd(), '.claude', 'ACTIVE-PLAN');
+      const planId = readFileSync(activePlanPath, 'utf-8').trim();
+      const taskPath = join(process.cwd(), '.claude', 'plans', planId, 'tasks', `${task.id}.json`);
+
+      const taskData = JSON.parse(readFileSync(taskPath, 'utf-8'));
+
+      if (!taskData.githubIssue) {
+        return;
+      }
+
+      const client = new GitHubClient(
+        config.getToken(),
+        config.getRepoInfo().owner,
+        config.getRepoInfo().repo
+      );
+
+      if (!client.isConfigured()) {
+        return;
+      }
+
+      // Update labels to "in review"
+      await client.updateIssueLabels(taskData.githubIssue, ['status: in-review', `phase: ${taskData.phase || 'implementation'}`]);
+
+      // Add comment with PR link
+      if (prUrl) {
+        const comment = `Pull request created: ${prUrl}\n\nTask is now in code review.`;
+        await client.addIssueComment(taskData.githubIssue, comment);
+      }
+
+      console.log(`✅ Updated GitHub issue #${taskData.githubIssue}`);
+    } catch (error) {
+      console.log(`\n⚠️  Failed to update GitHub issue: ${error.message}\n`);
+    }
+  }
+
+  static displaySummary(task, prUrl, tracker) {
+    console.log('\n┌─────────────────────────────────────────┐');
+    console.log('│  ✅ Commit Workflow Complete           │');
+    console.log('└─────────────────────────────────────────┘\n');
+
+    console.log(`📌 Task: ${task.id} - ${task.title}`);
+
+    if (prUrl) {
+      console.log(`🔗 PR: ${prUrl}`);
+    }
+
+    const completed = tracker.taskFiles.filter(t => t.status === 'completed').length;
+    const total = tracker.taskFiles.length;
+
+    console.log(`\n📊 Progress: ${completed}/${total} completed\n`);
+
+    console.log('💡 Next steps:');
+    console.log('   1. Review and merge PR on GitHub');
+    console.log('   2. After merge, run: agentic15 task next\n');
+  }
+
+  static getMainBranch() {
+    try {
+      // Try to detect main branch
+      const branches = execSync('git branch -r', { encoding: 'utf-8' });
+
+      if (branches.includes('origin/main')) {
+        return 'main';
+      } else if (branches.includes('origin/master')) {
+        return 'master';
+      }
+
+      return 'main'; // Default
+    } catch (e) {
+      return 'main';
+    }
+  }
+}

package/src/cli/PlanCommand.js

@@ -0,0 +1,123 @@
+import { execSync } from 'child_process';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+export class PlanCommand {
+  static async handle(description) {
+    // Check if plan already exists
+    const activePlanPath = join(process.cwd(), '.claude', 'ACTIVE-PLAN');
+
+    if (existsSync(activePlanPath)) {
+      const planId = readFileSync(activePlanPath, 'utf-8').trim();
+      const planPath = join(process.cwd(), '.claude', 'plans', planId);
+      const projectPlanPath = join(planPath, 'PROJECT-PLAN.json');
+
+      // Check if plan file exists
+      if (existsSync(projectPlanPath)) {
+        // Plan exists, check if it's locked
+        const lockedPath = join(planPath, '.plan-locked');
+
+        if (existsSync(lockedPath)) {
+          console.log('\n⚠️  Plan already locked');
+          console.log(`   Plan: ${planId}\n`);
+          this.showPlanStatus(planId);
+          process.exit(0);
+        }
+
+        // Plan exists but not locked - lock it
+        console.log('\n📋 Found existing plan, locking it...\n');
+        return this.lockPlan(planId);
+      } else {
+        // Requirements exist but plan not created yet
+        console.log('\n⚠️  Waiting for PROJECT-PLAN.json');
+        console.log(`   Tell Claude: "Create the project plan"\n`);
+        process.exit(0);
+      }
+    }
+
+    // No plan exists - create new one
+    if (!description) {
+      console.log('\n❌ Project description required');
+      console.log('   Usage: agentic15 plan "Build a calculator app"\n');
+      process.exit(1);
+    }
+
+    return this.generatePlan(description);
+  }
+
+  static generatePlan(description) {
+    console.log('\n📋 Generating new plan...\n');
+
+    try {
+      // Run plan:generate script
+      execSync(`npm run plan:generate "${description}"`, { stdio: 'inherit' });
+
+      // Find the generated plan
+      const plansDir = join(process.cwd(), '.claude', 'plans');
+      const plans = readdirSync(plansDir)
+        .filter(name => name.startsWith('plan-') && name.includes('-generated'));
+
+      if (plans.length === 0) {
+        console.log('\n❌ Failed to generate plan\n');
+        process.exit(1);
+      }
+
+      // Use the most recent generated plan
+      const planId = plans[plans.length - 1];
+
+      // Set as active plan
+      const activePlanPath = join(process.cwd(), '.claude', 'ACTIVE-PLAN');
+      writeFileSync(activePlanPath, planId);
+
+      console.log(`\n✅ Plan requirements created: ${planId}`);
+      console.log(`   Location: .claude/plans/${planId}/PROJECT-REQUIREMENTS.txt\n`);
+      console.log('💡 Next steps:');
+      console.log(`   1. Tell Claude: "Create the project plan"`);
+      console.log(`   2. When Claude is done, run: agentic15 plan\n`);
+    } catch (error) {
+      console.log(`\n❌ Failed to generate plan: ${error.message}\n`);
+      process.exit(1);
+    }
+  }
+
+  static lockPlan(planId) {
+    console.log(`📋 Locking plan: ${planId}\n`);
+
+    try {
+      // Run plan:init script
+      execSync('npm run plan:init', { stdio: 'inherit' });
+
+      console.log('\n✅ Plan locked successfully\n');
+
+      this.showPlanStatus(planId);
+
+      console.log('💡 Next step: agentic15 task next\n');
+    } catch (error) {
+      console.log(`\n❌ Failed to lock plan: ${error.message}\n`);
+      process.exit(1);
+    }
+  }
+
+  static showPlanStatus(planId) {
+    const trackerPath = join(process.cwd(), '.claude', 'plans', planId, 'TASK-TRACKER.json');
+
+    if (!existsSync(trackerPath)) {
+      return;
+    }
+
+    try {
+      const tracker = JSON.parse(readFileSync(trackerPath, 'utf-8'));
+
+      const total = tracker.taskFiles.length;
+      const completed = tracker.taskFiles.filter(t => t.status === 'completed').length;
+      const pending = tracker.taskFiles.filter(t => t.status === 'pending').length;
+
+      console.log('📊 Plan Status:');
+      console.log(`   Total Tasks: ${total}`);
+      console.log(`   Completed:   ${completed}`);
+      console.log(`   Pending:     ${pending}\n`);
+    } catch (e) {
+      // Ignore errors
+    }
+  }
+}