@howlil/ez-agents 2.0.0

package/get-shit-done/bin/lib/logger.cjs

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+
+/**
+ * GSD Logger — Centralized logging module for GSD workflow
+ * 
+ * Provides structured logging with levels (ERROR, WARN, INFO, DEBUG)
+ * Writes to .planning/logs/gsd-{timestamp}.log
+ * Replaces silent catch {} blocks with proper error logging
+ * 
+ * Usage:
+ *   const Logger = require('./logger.cjs');
+ *   const logger = new Logger();
+ *   logger.error('Something failed', { context: 'details' });
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class Logger {
+  /**
+   * Create a Logger instance
+   * @param {string} logDir - Directory for log files (default: .planning/logs)
+   */
+  constructor(logDir = '.planning/logs') {
+    this.logDir = logDir;
+    this.logFile = null;
+    this._ensureLogDir();
+  }
+
+  /**
+   * Ensure log directory exists and initialize log file
+   */
+  _ensureLogDir() {
+    if (!fs.existsSync(this.logDir)) {
+      fs.mkdirSync(this.logDir, { recursive: true });
+    }
+    this.logFile = path.join(this.logDir, `gsd-${Date.now()}.log`);
+  }
+
+  /**
+   * Get current log file path
+   * @returns {string} - Path to log file
+   */
+  getLogFile() {
+    return this.logFile;
+  }
+
+  /**
+   * Write a log entry
+   * @param {string} level - Log level (ERROR, WARN, INFO, DEBUG)
+   * @param {string} message - Log message
+   * @param {Object} context - Additional context data
+   */
+  log(level, message, context = {}) {
+    const entry = {
+      timestamp: new Date().toISOString(),
+      level,
+      message,
+      context,
+      pid: process.pid
+    };
+
+    try {
+      fs.appendFileSync(this.logFile, JSON.stringify(entry) + '\n');
+      
+      // Always output ERROR level to console for visibility
+      if (level === 'ERROR') {
+        console.error(`[GSD ${level}] ${message}`);
+      }
+    } catch (err) {
+      // Fallback: log to console if file write fails
+      console.error(`[GSD ${level}] ${message} (file write failed: ${err.message})`);
+    }
+  }
+
+  /**
+   * Log an ERROR level message
+   * @param {string} msg - Error message
+   * @param {Object} ctx - Additional context
+   */
+  error(msg, ctx) {
+    this.log('ERROR', msg, ctx);
+  }
+
+  /**
+   * Log a WARN level message
+   * @param {string} msg - Warning message
+   * @param {Object} ctx - Additional context
+   */
+  warn(msg, ctx) {
+    this.log('WARN', msg, ctx);
+  }
+
+  /**
+   * Log an INFO level message
+   * @param {string} msg - Info message
+   * @param {Object} ctx - Additional context
+   */
+  info(msg, ctx) {
+    this.log('INFO', msg, ctx);
+  }
+
+  /**
+   * Log a DEBUG level message
+   * @param {string} msg - Debug message
+   * @param {Object} ctx - Additional context
+   */
+  debug(msg, ctx) {
+    this.log('DEBUG', msg, ctx);
+  }
+}
+
+// Singleton instance for default usage
+const defaultLogger = new Logger();
+
+module.exports = Logger;
+module.exports.defaultLogger = defaultLogger;

package/get-shit-done/bin/lib/milestone.cjs

@@ -0,0 +1,241 @@
+/**
+ * Milestone — Milestone and requirements lifecycle operations
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { escapeRegex, getMilestonePhaseFilter, output, error } = require('./core.cjs');
+const { extractFrontmatter } = require('./frontmatter.cjs');
+const { writeStateMd } = require('./state.cjs');
+
+function cmdRequirementsMarkComplete(cwd, reqIdsRaw, raw) {
+  if (!reqIdsRaw || reqIdsRaw.length === 0) {
+    error('requirement IDs required. Usage: requirements mark-complete REQ-01,REQ-02 or REQ-01 REQ-02');
+  }
+
+  // Accept comma-separated, space-separated, or bracket-wrapped: [REQ-01, REQ-02]
+  const reqIds = reqIdsRaw
+    .join(' ')
+    .replace(/[\[\]]/g, '')
+    .split(/[,\s]+/)
+    .map(r => r.trim())
+    .filter(Boolean);
+
+  if (reqIds.length === 0) {
+    error('no valid requirement IDs found');
+  }
+
+  const reqPath = path.join(cwd, '.planning', 'REQUIREMENTS.md');
+  if (!fs.existsSync(reqPath)) {
+    output({ updated: false, reason: 'REQUIREMENTS.md not found', ids: reqIds }, raw, 'no requirements file');
+    return;
+  }
+
+  let reqContent = fs.readFileSync(reqPath, 'utf-8');
+  const updated = [];
+  const notFound = [];
+
+  for (const reqId of reqIds) {
+    let found = false;
+    const reqEscaped = escapeRegex(reqId);
+
+    // Update checkbox: - [ ] **REQ-ID** → - [x] **REQ-ID**
+    const checkboxPattern = new RegExp(`(-\\s*\\[)[ ](\\]\\s*\\*\\*${reqEscaped}\\*\\*)`, 'gi');
+    if (checkboxPattern.test(reqContent)) {
+      reqContent = reqContent.replace(checkboxPattern, '$1x$2');
+      found = true;
+    }
+
+    // Update traceability table: | REQ-ID | Phase N | Pending | → | REQ-ID | Phase N | Complete |
+    const tablePattern = new RegExp(`(\\|\\s*${reqEscaped}\\s*\\|[^|]+\\|)\\s*Pending\\s*(\\|)`, 'gi');
+    if (tablePattern.test(reqContent)) {
+      // Re-read since test() advances lastIndex for global regex
+      reqContent = reqContent.replace(
+        new RegExp(`(\\|\\s*${reqEscaped}\\s*\\|[^|]+\\|)\\s*Pending\\s*(\\|)`, 'gi'),
+        '$1 Complete $2'
+      );
+      found = true;
+    }
+
+    if (found) {
+      updated.push(reqId);
+    } else {
+      notFound.push(reqId);
+    }
+  }
+
+  if (updated.length > 0) {
+    fs.writeFileSync(reqPath, reqContent, 'utf-8');
+  }
+
+  output({
+    updated: updated.length > 0,
+    marked_complete: updated,
+    not_found: notFound,
+    total: reqIds.length,
+  }, raw, `${updated.length}/${reqIds.length} requirements marked complete`);
+}
+
+function cmdMilestoneComplete(cwd, version, options, raw) {
+  if (!version) {
+    error('version required for milestone complete (e.g., v1.0)');
+  }
+
+  const roadmapPath = path.join(cwd, '.planning', 'ROADMAP.md');
+  const reqPath = path.join(cwd, '.planning', 'REQUIREMENTS.md');
+  const statePath = path.join(cwd, '.planning', 'STATE.md');
+  const milestonesPath = path.join(cwd, '.planning', 'MILESTONES.md');
+  const archiveDir = path.join(cwd, '.planning', 'milestones');
+  const phasesDir = path.join(cwd, '.planning', 'phases');
+  const today = new Date().toISOString().split('T')[0];
+  const milestoneName = options.name || version;
+
+  // Ensure archive directory exists
+  fs.mkdirSync(archiveDir, { recursive: true });
+
+  // Scope stats and accomplishments to only the phases belonging to the
+  // current milestone's ROADMAP.  Uses the shared filter from core.cjs
+  // (same logic used by cmdPhasesList and other callers).
+  const isDirInMilestone = getMilestonePhaseFilter(cwd);
+
+  // Gather stats from phases (scoped to current milestone only)
+  let phaseCount = 0;
+  let totalPlans = 0;
+  let totalTasks = 0;
+  const accomplishments = [];
+
+  try {
+    const entries = fs.readdirSync(phasesDir, { withFileTypes: true });
+    const dirs = entries.filter(e => e.isDirectory()).map(e => e.name).sort();
+
+    for (const dir of dirs) {
+      if (!isDirInMilestone(dir)) continue;
+
+      phaseCount++;
+      const phaseFiles = fs.readdirSync(path.join(phasesDir, dir));
+      const plans = phaseFiles.filter(f => f.endsWith('-PLAN.md') || f === 'PLAN.md');
+      const summaries = phaseFiles.filter(f => f.endsWith('-SUMMARY.md') || f === 'SUMMARY.md');
+      totalPlans += plans.length;
+
+      // Extract one-liners from summaries
+      for (const s of summaries) {
+        try {
+          const content = fs.readFileSync(path.join(phasesDir, dir, s), 'utf-8');
+          const fm = extractFrontmatter(content);
+          if (fm['one-liner']) {
+            accomplishments.push(fm['one-liner']);
+          }
+          // Count tasks
+          const taskMatches = content.match(/##\s*Task\s*\d+/gi) || [];
+          totalTasks += taskMatches.length;
+        } catch {}
+      }
+    }
+  } catch {}
+
+  // Archive ROADMAP.md
+  if (fs.existsSync(roadmapPath)) {
+    const roadmapContent = fs.readFileSync(roadmapPath, 'utf-8');
+    fs.writeFileSync(path.join(archiveDir, `${version}-ROADMAP.md`), roadmapContent, 'utf-8');
+  }
+
+  // Archive REQUIREMENTS.md
+  if (fs.existsSync(reqPath)) {
+    const reqContent = fs.readFileSync(reqPath, 'utf-8');
+    const archiveHeader = `# Requirements Archive: ${version} ${milestoneName}\n\n**Archived:** ${today}\n**Status:** SHIPPED\n\nFor current requirements, see \`.planning/REQUIREMENTS.md\`.\n\n---\n\n`;
+    fs.writeFileSync(path.join(archiveDir, `${version}-REQUIREMENTS.md`), archiveHeader + reqContent, 'utf-8');
+  }
+
+  // Archive audit file if exists
+  const auditFile = path.join(cwd, '.planning', `${version}-MILESTONE-AUDIT.md`);
+  if (fs.existsSync(auditFile)) {
+    fs.renameSync(auditFile, path.join(archiveDir, `${version}-MILESTONE-AUDIT.md`));
+  }
+
+  // Create/append MILESTONES.md entry
+  const accomplishmentsList = accomplishments.map(a => `- ${a}`).join('\n');
+  const milestoneEntry = `## ${version} ${milestoneName} (Shipped: ${today})\n\n**Phases completed:** ${phaseCount} phases, ${totalPlans} plans, ${totalTasks} tasks\n\n**Key accomplishments:**\n${accomplishmentsList || '- (none recorded)'}\n\n---\n\n`;
+
+  if (fs.existsSync(milestonesPath)) {
+    const existing = fs.readFileSync(milestonesPath, 'utf-8');
+    if (!existing.trim()) {
+      // Empty file — treat like new
+      fs.writeFileSync(milestonesPath, `# Milestones\n\n${milestoneEntry}`, 'utf-8');
+    } else {
+      // Insert after the header line(s) for reverse chronological order (newest first)
+      const headerMatch = existing.match(/^(#{1,3}\s+[^\n]*\n\n?)/);
+      if (headerMatch) {
+        const header = headerMatch[1];
+        const rest = existing.slice(header.length);
+        fs.writeFileSync(milestonesPath, header + milestoneEntry + rest, 'utf-8');
+      } else {
+        // No recognizable header — prepend the entry
+        fs.writeFileSync(milestonesPath, milestoneEntry + existing, 'utf-8');
+      }
+    }
+  } else {
+    fs.writeFileSync(milestonesPath, `# Milestones\n\n${milestoneEntry}`, 'utf-8');
+  }
+
+  // Update STATE.md
+  if (fs.existsSync(statePath)) {
+    let stateContent = fs.readFileSync(statePath, 'utf-8');
+    stateContent = stateContent.replace(
+      /(\*\*Status:\*\*\s*).*/,
+      `$1${version} milestone complete`
+    );
+    stateContent = stateContent.replace(
+      /(\*\*Last Activity:\*\*\s*).*/,
+      `$1${today}`
+    );
+    stateContent = stateContent.replace(
+      /(\*\*Last Activity Description:\*\*\s*).*/,
+      `$1${version} milestone completed and archived`
+    );
+    writeStateMd(statePath, stateContent, cwd);
+  }
+
+  // Archive phase directories if requested
+  let phasesArchived = false;
+  if (options.archivePhases) {
+    try {
+      const phaseArchiveDir = path.join(archiveDir, `${version}-phases`);
+      fs.mkdirSync(phaseArchiveDir, { recursive: true });
+
+      const phaseEntries = fs.readdirSync(phasesDir, { withFileTypes: true });
+      const phaseDirNames = phaseEntries.filter(e => e.isDirectory()).map(e => e.name);
+      let archivedCount = 0;
+      for (const dir of phaseDirNames) {
+        if (!isDirInMilestone(dir)) continue;
+        fs.renameSync(path.join(phasesDir, dir), path.join(phaseArchiveDir, dir));
+        archivedCount++;
+      }
+      phasesArchived = archivedCount > 0;
+    } catch {}
+  }
+
+  const result = {
+    version,
+    name: milestoneName,
+    date: today,
+    phases: phaseCount,
+    plans: totalPlans,
+    tasks: totalTasks,
+    accomplishments,
+    archived: {
+      roadmap: fs.existsSync(path.join(archiveDir, `${version}-ROADMAP.md`)),
+      requirements: fs.existsSync(path.join(archiveDir, `${version}-REQUIREMENTS.md`)),
+      audit: fs.existsSync(path.join(archiveDir, `${version}-MILESTONE-AUDIT.md`)),
+      phases: phasesArchived,
+    },
+    milestones_updated: true,
+    state_updated: fs.existsSync(statePath),
+  };
+
+  output(result, raw);
+}
+
+module.exports = {
+  cmdRequirementsMarkComplete,
+  cmdMilestoneComplete,
+};

package/get-shit-done/bin/lib/model-provider.cjs

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+
+/**
+ * GSD Model Provider — Unified API for multiple AI providers
+ * 
+ * Supports: Anthropic, Moonshot (Kimi), Alibaba (Qwen), OpenAI
+ * 
+ * Usage:
+ *   const ModelProvider = require('./model-provider.cjs');
+ *   const model = new ModelProvider({ provider: 'anthropic', model: 'sonnet' });
+ *   const response = await model.chat([{ role: 'user', content: 'Hello' }]);
+ */
+
+const Logger = require('./logger.cjs');
+const logger = new Logger();
+
+class ModelProvider {
+  /**
+   * Create model provider
+   * @param {Object} config - Configuration
+   */
+  constructor(config) {
+    this.provider = config.provider || 'anthropic';
+    this.model = config.model || 'sonnet';
+    this.apiKey = config.apiKey || process.env[`${this.provider.toUpperCase()}_API_KEY`];
+    
+    if (!this.apiKey) {
+      logger.warn('API key not configured', { provider: this.provider });
+    }
+  }
+
+  /**
+   * Send chat message
+   * @param {Object[]} messages - Chat messages
+   * @param {Object} options - Chat options
+   * @returns {Promise<Object>} - Response
+   */
+  async chat(messages, options = {}) {
+    logger.info('Chat request', { 
+      provider: this.provider, 
+      model: this.model,
+      messageCount: messages.length 
+    });
+
+    switch (this.provider) {
+      case 'anthropic':
+        return this._chatAnthropic(messages, options);
+      case 'moonshot':
+        return this._chatMoonshot(messages, options);
+      case 'alibaba':
+        return this._chatQwen(messages, options);
+      case 'openai':
+        return this._chatOpenAI(messages, options);
+      default:
+        throw new Error(`Unsupported provider: ${this.provider}`);
+    }
+  }
+
+  /**
+   * Anthropic Claude API
+   */
+  async _chatAnthropic(messages, options) {
+    // Placeholder - would use @anthropic-ai/sdk in production
+    logger.debug('Anthropic chat', { model: this.model });
+    return {
+      content: '[Anthropic response placeholder]',
+      provider: 'anthropic',
+      model: this.model
+    };
+  }
+
+  /**
+   * Moonshot (Kimi) API
+   */
+  async _chatMoonshot(messages, options) {
+    // Placeholder - would use moonshot SDK in production
+    logger.debug('Moonshot chat', { model: this.model });
+    return {
+      content: '[Moonshot response placeholder]',
+      provider: 'moonshot',
+      model: this.model
+    };
+  }
+
+  /**
+   * Alibaba Qwen API
+   */
+  async _chatQwen(messages, options) {
+    // Placeholder - would use DashScope SDK in production
+    logger.debug('Qwen chat', { model: this.model });
+    return {
+      content: '[Qwen response placeholder]',
+      provider: 'alibaba',
+      model: this.model
+    };
+  }
+
+  /**
+   * OpenAI API
+   */
+  async _chatOpenAI(messages, options) {
+    // Placeholder - would use openai SDK in production
+    logger.debug('OpenAI chat', { model: this.model });
+    return {
+      content: '[OpenAI response placeholder]',
+      provider: 'openai',
+      model: this.model
+    };
+  }
+
+  /**
+   * Count tokens (approximate)
+   * @param {string} text - Text to count
+   * @returns {number} - Approximate token count
+   */
+  countTokens(text) {
+    // Rough estimate: 1 token ≈ 4 characters
+    return Math.ceil(text.length / 4);
+  }
+
+  /**
+   * Get provider info
+   * @returns {Object} - Provider information
+   */
+  getInfo() {
+    return {
+      provider: this.provider,
+      model: this.model,
+      hasApiKey: !!this.apiKey
+    };
+  }
+}
+
+/**
+ * Create provider from config
+ * @param {Object} config - Provider config
+ * @returns {ModelProvider} - Model provider instance
+ */
+function createProvider(config) {
+  return new ModelProvider(config);
+}
+
+module.exports = {
+  ModelProvider,
+  createProvider
+};