@agentic15.com/agentic15-claude-zen 1.0.1 → 2.0.0

package/src/cli/StatusCommand.js

@@ -0,0 +1,156 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+
+export class StatusCommand {
+  static show() {
+    console.log('\n📊 Project Status\n');
+
+    // Load tracker
+    const tracker = this.loadTracker();
+
+    if (!tracker) {
+      console.log('❌ No active plan found\n');
+      process.exit(1);
+    }
+
+    // Calculate statistics
+    const completed = tracker.taskFiles.filter(t => t.status === 'completed');
+    const inProgress = tracker.taskFiles.filter(t => t.status === 'in_progress');
+    const pending = tracker.taskFiles.filter(t => t.status === 'pending');
+    const blocked = tracker.taskFiles.filter(t => t.status === 'blocked');
+    const total = tracker.taskFiles.length;
+
+    // Display plan info
+    console.log(`   Plan: ${tracker.planId}`);
+    console.log(`   Total Tasks: ${total}\n`);
+
+    // Progress bar
+    const completedPercent = Math.round((completed.length / total) * 100);
+    const barLength = 30;
+    const filledLength = Math.round((completedPercent / 100) * barLength);
+    const bar = '█'.repeat(filledLength) + '░'.repeat(barLength - filledLength);
+
+    console.log(`   Progress: [${bar}] ${completedPercent}%\n`);
+
+    // Status breakdown
+    console.log('   Status Breakdown:');
+    console.log(`   ✅ Completed:   ${completed.length}`);
+    console.log(`   🔄 In Progress: ${inProgress.length}`);
+    console.log(`   ⏳ Pending:     ${pending.length}`);
+
+    if (blocked.length > 0) {
+      console.log(`   🚫 Blocked:     ${blocked.length}`);
+    }
+
+    console.log('');
+
+    // Current task
+    if (inProgress.length > 0) {
+      const current = inProgress[0];
+      console.log('   🔄 Current Task:');
+      console.log(`      ${current.id}: ${current.title}`);
+
+      // Show changed files
+      try {
+        const diff = execSync('git diff --name-only', { encoding: 'utf-8' });
+        const staged = execSync('git diff --cached --name-only', { encoding: 'utf-8' });
+
+        const allChanges = new Set([
+          ...diff.trim().split('\n').filter(Boolean),
+          ...staged.trim().split('\n').filter(Boolean)
+        ]);
+
+        if (allChanges.size > 0) {
+          console.log(`\n      📝 Modified files (${allChanges.size}):`);
+          Array.from(allChanges).slice(0, 10).forEach(file => {
+            console.log(`         - ${file}`);
+          });
+
+          if (allChanges.size > 10) {
+            console.log(`         ... and ${allChanges.size - 10} more`);
+          }
+        }
+      } catch (e) {
+        // Ignore git errors
+      }
+
+      console.log('');
+      console.log('      💡 Next step: agentic15 commit');
+    } else if (pending.length > 0) {
+      console.log('   📌 Next Task:');
+      const next = pending[0];
+      console.log(`      ${next.id}: ${next.title}`);
+      console.log('');
+      console.log('      💡 Next step: agentic15 task next');
+    } else if (blocked.length > 0) {
+      console.log('   🚫 Blocked Tasks:');
+      blocked.slice(0, 3).forEach(task => {
+        console.log(`      ${task.id}: ${task.title}`);
+      });
+
+      if (blocked.length > 3) {
+        console.log(`      ... and ${blocked.length - 3} more`);
+      }
+    } else {
+      console.log('   🎉 All tasks completed!');
+    }
+
+    console.log('');
+
+    // Recent activity
+    const recentCompleted = completed
+      .filter(t => t.completedAt)
+      .sort((a, b) => new Date(b.completedAt) - new Date(a.completedAt))
+      .slice(0, 3);
+
+    if (recentCompleted.length > 0) {
+      console.log('   📜 Recently Completed:');
+      recentCompleted.forEach(task => {
+        const date = new Date(task.completedAt);
+        const timeAgo = this.getTimeAgo(date);
+        console.log(`      ✓ ${task.id}: ${task.title} (${timeAgo})`);
+      });
+      console.log('');
+    }
+  }
+
+  static loadTracker() {
+    const activePlanPath = join(process.cwd(), '.claude', 'ACTIVE-PLAN');
+
+    if (!existsSync(activePlanPath)) {
+      return null;
+    }
+
+    const planId = readFileSync(activePlanPath, 'utf-8').trim();
+    const trackerPath = join(process.cwd(), '.claude', 'plans', planId, 'TASK-TRACKER.json');
+
+    if (!existsSync(trackerPath)) {
+      return null;
+    }
+
+    return JSON.parse(readFileSync(trackerPath, 'utf-8'));
+  }
+
+  static getTimeAgo(date) {
+    const seconds = Math.floor((new Date() - date) / 1000);
+
+    const intervals = {
+      year: 31536000,
+      month: 2592000,
+      week: 604800,
+      day: 86400,
+      hour: 3600,
+      minute: 60
+    };
+
+    for (const [unit, secondsInUnit] of Object.entries(intervals)) {
+      const interval = Math.floor(seconds / secondsInUnit);
+      if (interval >= 1) {
+        return `${interval} ${unit}${interval === 1 ? '' : 's'} ago`;
+      }
+    }
+
+    return 'just now';
+  }
+}

package/src/cli/TaskCommand.js

@@ -0,0 +1,249 @@
+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';
+import { TaskIssueMapper } from '../core/TaskIssueMapper.js';
+
+export class TaskCommand {
+  static async handle(action, taskId) {
+    switch (action) {
+      case 'start':
+        return this.startTask(taskId);
+      case 'next':
+        return this.startNext();
+      case 'status':
+        return this.showStatus();
+      default:
+        console.log(`\n❌ Unknown action: ${action}`);
+        console.log('   Valid actions: start, next, status\n');
+        process.exit(1);
+    }
+  }
+
+  static async startTask(taskId) {
+    if (!taskId) {
+      console.log('\n❌ Task ID required for "start" action');
+      console.log('   Usage: agentic15 task start TASK-001\n');
+      process.exit(1);
+    }
+
+    // Load task tracker
+    const tracker = this.loadTracker();
+    const task = tracker.taskFiles.find(t => t.id === taskId);
+
+    if (!task) {
+      console.log(`\n❌ Task not found: ${taskId}\n`);
+      process.exit(1);
+    }
+
+    if (task.status === 'completed') {
+      console.log(`\n⚠️  Task ${taskId} is already completed\n`);
+      process.exit(1);
+    }
+
+    // Check if another task is in progress
+    const inProgress = tracker.taskFiles.find(t => t.status === 'in_progress');
+    if (inProgress && inProgress.id !== taskId) {
+      console.log(`\n⚠️  Task ${inProgress.id} is already in progress`);
+      console.log(`   Complete it first with: agentic15 commit\n`);
+      process.exit(1);
+    }
+
+    // Create feature branch
+    const branchName = `feature/${taskId.toLowerCase()}`;
+    try {
+      execSync(`git checkout -b ${branchName}`, { stdio: 'inherit' });
+    } catch (error) {
+      // Branch might already exist
+      try {
+        execSync(`git checkout ${branchName}`, { stdio: 'inherit' });
+      } catch (e) {
+        console.log(`\n❌ Failed to create/checkout branch: ${branchName}\n`);
+        process.exit(1);
+      }
+    }
+
+    // Update task status
+    task.status = 'in_progress';
+    task.startedAt = new Date().toISOString();
+    this.saveTracker(tracker);
+
+    // Create GitHub issue if enabled
+    let githubIssue = null;
+    const config = new GitHubConfig(process.cwd());
+    if (config.isAutoCreateEnabled()) {
+      githubIssue = await this.createGitHubIssue(task, config);
+    }
+
+    // Display task details
+    this.displayTaskDetails(task, githubIssue, tracker);
+  }
+
+  static async startNext() {
+    const tracker = this.loadTracker();
+
+    // Find next pending task
+    const nextTask = tracker.taskFiles.find(t => t.status === 'pending');
+
+    if (!nextTask) {
+      console.log('\n✅ No more pending tasks!\n');
+      const completed = tracker.taskFiles.filter(t => t.status === 'completed').length;
+      const total = tracker.taskFiles.length;
+      console.log(`   Progress: ${completed}/${total} tasks completed\n`);
+      process.exit(0);
+    }
+
+    console.log(`\n▶️  Auto-starting next task: ${nextTask.id}\n`);
+    return this.startTask(nextTask.id);
+  }
+
+  static showStatus() {
+    const tracker = this.loadTracker();
+
+    const inProgress = tracker.taskFiles.find(t => t.status === 'in_progress');
+    const completed = tracker.taskFiles.filter(t => t.status === 'completed').length;
+    const pending = tracker.taskFiles.filter(t => t.status === 'pending').length;
+    const total = tracker.taskFiles.length;
+
+    console.log('\n📊 Task Status\n');
+    console.log(`   Plan: ${tracker.planId}`);
+    console.log(`   Progress: ${completed}/${total} completed (${pending} pending)\n`);
+
+    if (inProgress) {
+      console.log(`   🔄 Currently working on: ${inProgress.id}`);
+      console.log(`   📌 ${inProgress.title}`);
+
+      // Show changed files
+      try {
+        const diff = execSync('git diff --name-only', { encoding: 'utf-8' });
+        if (diff.trim()) {
+          console.log(`\n   📝 Changed files:`);
+          diff.trim().split('\n').forEach(file => {
+            console.log(`      - ${file}`);
+          });
+        }
+      } catch (e) {
+        // Ignore
+      }
+    } else {
+      console.log('   ℹ️  No task currently in progress');
+      console.log(`   Run: agentic15 task next\n`);
+    }
+
+    console.log('');
+  }
+
+  static async createGitHubIssue(task, config) {
+    try {
+      const client = new GitHubClient(
+        config.getToken(),
+        config.getRepoInfo().owner,
+        config.getRepoInfo().repo
+      );
+
+      if (!client.isConfigured()) {
+        console.log('\n⚠️  GitHub not configured. Skipping issue creation.');
+        console.log('   Run: agentic15 auth setup\n');
+        return null;
+      }
+
+      // Load full task details
+      const taskPath = this.getTaskPath(task.id);
+      const taskData = JSON.parse(readFileSync(taskPath, 'utf-8'));
+
+      const { title, body, labels } = TaskIssueMapper.mapTaskToIssue(taskData);
+      const issueNumber = await client.createIssue(title, body, labels);
+
+      if (issueNumber) {
+        // Save issue number to task
+        taskData.githubIssue = issueNumber;
+        writeFileSync(taskPath, JSON.stringify(taskData, null, 2));
+
+        console.log(`\n✓ Created GitHub issue #${issueNumber}`);
+        const repoInfo = config.getRepoInfo();
+        console.log(`  https://github.com/${repoInfo.owner}/${repoInfo.repo}/issues/${issueNumber}\n`);
+
+        return issueNumber;
+      }
+    } catch (error) {
+      console.log(`\n⚠️  Failed to create GitHub issue: ${error.message}\n`);
+    }
+
+    return null;
+  }
+
+  static displayTaskDetails(task, githubIssue, tracker) {
+    console.log(`\n✅ Started task: ${task.id}`);
+    console.log(`📋 Plan: ${tracker.planId}\n`);
+    console.log(`📌 ${task.title}`);
+
+    if (task.description) {
+      console.log(`📝 ${task.description}\n`);
+    }
+
+    if (task.phase) {
+      console.log(`🔧 Phase: ${task.phase}`);
+    }
+
+    if (githubIssue) {
+      const config = new GitHubConfig(process.cwd());
+      const repoInfo = config.getRepoInfo();
+      console.log(`🔗 GitHub Issue: https://github.com/${repoInfo.owner}/${repoInfo.repo}/issues/${githubIssue}`);
+    }
+
+    // Load full task for completion criteria
+    try {
+      const taskPath = this.getTaskPath(task.id);
+      const taskData = JSON.parse(readFileSync(taskPath, 'utf-8'));
+
+      if (taskData.completionCriteria && taskData.completionCriteria.length > 0) {
+        console.log(`\n✓ Completion criteria:`);
+        taskData.completionCriteria.forEach((criteria, idx) => {
+          console.log(`  ${idx + 1}. ${criteria}`);
+        });
+      }
+    } catch (e) {
+      // Ignore
+    }
+
+    console.log(`\n💡 Next steps:`);
+    console.log(`   1. Tell Claude: "Write code for ${task.id}"`);
+    console.log(`   2. When done: agentic15 commit\n`);
+  }
+
+  static loadTracker() {
+    const activePlanPath = join(process.cwd(), '.claude', 'ACTIVE-PLAN');
+
+    if (!existsSync(activePlanPath)) {
+      console.log('\n❌ No active plan found');
+      console.log('   Run: agentic15 plan "project description"\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');
+      console.log('   Run: agentic15 plan\n');
+      process.exit(1);
+    }
+
+    return JSON.parse(readFileSync(trackerPath, 'utf-8'));
+  }
+
+  static saveTracker(tracker) {
+    const activePlanPath = join(process.cwd(), '.claude', 'ACTIVE-PLAN');
+    const planId = readFileSync(activePlanPath, 'utf-8').trim();
+    const trackerPath = join(process.cwd(), '.claude', 'plans', planId, 'TASK-TRACKER.json');
+
+    writeFileSync(trackerPath, JSON.stringify(tracker, null, 2));
+  }
+
+  static getTaskPath(taskId) {
+    const activePlanPath = join(process.cwd(), '.claude', 'ACTIVE-PLAN');
+    const planId = readFileSync(activePlanPath, 'utf-8').trim();
+    return join(process.cwd(), '.claude', 'plans', planId, 'tasks', `${taskId}.json`);
+  }
+}

package/src/core/GitHubClient.js

@@ -0,0 +1,170 @@
+/**
+ * Copyright 2024-2025 agentic15.com
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Octokit } from '@octokit/rest';
+
+/**
+ * GitHubClient - Handles all GitHub API interactions
+ *
+ * Single Responsibility: Communicate with GitHub Issues API
+ *
+ * This class encapsulates all GitHub API calls and provides graceful
+ * degradation when GitHub integration is unavailable or disabled.
+ */
+export class GitHubClient {
+  /**
+   * Initialize GitHub client
+   *
+   * @param {string|null} token - GitHub Personal Access Token
+   * @param {string|null} owner - Repository owner
+   * @param {string|null} repo - Repository name
+   */
+  constructor(token, owner, repo) {
+    if (!token || !owner || !repo) {
+      this.configured = false;
+      this.octokit = null;
+      this.owner = null;
+      this.repo = null;
+      return;
+    }
+
+    this.configured = true;
+    this.octokit = new Octokit({ auth: token });
+    this.owner = owner;
+    this.repo = repo;
+  }
+
+  /**
+   * Check if GitHub client is configured and ready
+   *
+   * @returns {boolean} True if configured, false otherwise
+   */
+  isConfigured() {
+    return this.configured;
+  }
+
+  /**
+   * Create a new GitHub issue
+   *
+   * @param {string} title - Issue title
+   * @param {string} body - Issue body (markdown supported)
+   * @param {string[]} labels - Array of label names
+   * @returns {Promise<number|null>} Issue number if created, null on failure
+   */
+  async createIssue(title, body, labels = []) {
+    if (!this.configured) {
+      return null;
+    }
+
+    try {
+      const response = await this.octokit.issues.create({
+        owner: this.owner,
+        repo: this.repo,
+        title,
+        body,
+        labels
+      });
+      return response.data.number;
+    } catch (error) {
+      console.warn('⚠ Failed to create GitHub issue:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Update labels on an existing GitHub issue
+   *
+   * @param {number} issueNumber - Issue number
+   * @param {string[]} labels - Array of label names to set
+   * @returns {Promise<boolean>} True if updated, false on failure
+   */
+  async updateIssueLabels(issueNumber, labels) {
+    if (!this.configured || !issueNumber) {
+      return false;
+    }
+
+    try {
+      await this.octokit.issues.update({
+        owner: this.owner,
+        repo: this.repo,
+        issue_number: issueNumber,
+        labels
+      });
+      return true;
+    } catch (error) {
+      console.warn('⚠ Failed to update issue labels:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Add a comment to an existing GitHub issue
+   *
+   * @param {number} issueNumber - Issue number
+   * @param {string} comment - Comment text (markdown supported)
+   * @returns {Promise<boolean>} True if added, false on failure
+   */
+  async addIssueComment(issueNumber, comment) {
+    if (!this.configured || !issueNumber) {
+      return false;
+    }
+
+    try {
+      await this.octokit.issues.createComment({
+        owner: this.owner,
+        repo: this.repo,
+        issue_number: issueNumber,
+        body: comment
+      });
+      return true;
+    } catch (error) {
+      console.warn('⚠ Failed to add issue comment:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Close a GitHub issue with optional comment
+   *
+   * @param {number} issueNumber - Issue number
+   * @param {string|null} comment - Optional closing comment
+   * @returns {Promise<boolean>} True if closed, false on failure
+   */
+  async closeIssue(issueNumber, comment = null) {
+    if (!this.configured || !issueNumber) {
+      return false;
+    }
+
+    try {
+      // Add comment first if provided
+      if (comment) {
+        await this.addIssueComment(issueNumber, comment);
+      }
+
+      // Close the issue
+      await this.octokit.issues.update({
+        owner: this.owner,
+        repo: this.repo,
+        issue_number: issueNumber,
+        state: 'closed'
+      });
+      return true;
+    } catch (error) {
+      console.warn('⚠ Failed to close issue:', error.message);
+      return false;
+    }
+  }
+}