@zibby/cli 0.1.5

package/src/commands/analyze-graph.js

@@ -0,0 +1,334 @@
+#!/usr/bin/env node
+
+/**
+ * Analyze Command with Graph Architecture
+ * 
+ * Uses multi-node graph workflow for comprehensive analysis:
+ * - Ticket analysis
+ * - Code implementation generation (with git diff)
+ * - Test case generation
+ * - Complexity assessment
+ */
+
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { readFileSync, existsSync } from 'fs';
+import { compileGraph, validateGraphConfig } from '@zibby/core/framework/graph-compiler.js';
+import { WorkflowGraph } from '@zibby/core/framework/graph.js';
+import { buildAnalysisGraph } from '@zibby/core/templates/code-analysis/graph.js';
+import { analysisStateSchema } from '@zibby/core/templates/code-analysis/state.js';
+import '@zibby/core/templates/register-nodes.js';
+import { fetchExecutionContext } from '../utils/execution-context.js';
+import { reportProgress, reportArtifact, reportFinalStatus } from '../utils/progress-reporter.js';
+import { writeMcpConfig } from '@zibby/core/utils/mcp-config-writer.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Node execution middleware - Captures logs and reports progress
+ * This is configured OUTSIDE the framework and passed in
+ */
+// Maps node names → how to extract their artifact from the node result
+const NODE_ARTIFACT_MAP = {
+  analyze_ticket: (result) => ({
+    key: 'analysis',
+    value: { raw: result.raw, structured: result.output }
+  }),
+  generate_code: (result) => ({
+    key: 'codeImplementation',
+    value: result.output?.codeImplementation
+  }),
+  generate_test_cases: (result) => ({
+    key: 'tests',
+    value: result.output?.tests
+  }),
+  finalize: (result) => ({
+    key: 'report',
+    value: result.output?.report
+  }),
+};
+
+function createLogCapturingMiddleware(reportProgressFn, reportArtifactFn) {
+  return async function nodeMiddleware(nodeName, executeNode, state) {
+    const startTime = Date.now();
+    const logBuffer = [];
+    let lastSentLogs = '';
+
+    const originalLog = console.log;
+    const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+    const originalStderrWrite = process.stderr.write.bind(process.stderr);
+
+    // Flag to prevent double-capture: console.log internally calls process.stdout.write
+    let insideConsoleLog = false;
+
+    console.log = (...args) => {
+      const message = args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
+      logBuffer.push(message);
+      insideConsoleLog = true;
+      originalLog(...args);
+      insideConsoleLog = false;
+    };
+
+    // Capture direct process.stdout.write (agent streaming output) but skip console.log echoes
+    let stdoutLineBuffer = '';
+    process.stdout.write = (chunk, encoding, callback) => {
+      if (!insideConsoleLog) {
+        const text = typeof chunk === 'string' ? chunk : chunk.toString();
+        stdoutLineBuffer += text;
+        const lines = stdoutLineBuffer.split('\n');
+        stdoutLineBuffer = lines.pop() || '';
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed) {
+            logBuffer.push(trimmed);
+          }
+        }
+      }
+      return originalStdoutWrite(chunk, encoding, callback);
+    };
+    
+    originalLog(`[Middleware] Started capturing logs for ${nodeName}`);
+
+    let timerCleared = false;
+    const liveLogInterval = setInterval(() => {
+      if (timerCleared) return;
+      
+      const currentLogs = logBuffer.join('\n');
+      if (currentLogs !== lastSentLogs && currentLogs.length > 0) {
+        lastSentLogs = currentLogs;
+        // Write middleware status to stderr to avoid interleaving with agent streaming on stdout
+        originalStderrWrite(`📡 [Middleware] Sending live update for ${nodeName}: ${currentLogs.length} chars, ${logBuffer.length} lines\n`);
+        reportProgressFn(nodeName, 'in_progress', currentLogs, state).catch((err) => {
+          originalStderrWrite(`⚠️  [Middleware] Failed to send live update: ${err.message}\n`);
+        });
+      }
+    }, 500);
+
+    try {
+      await reportProgressFn(nodeName, 'in_progress', '', state);
+
+      const result = await executeNode();
+      const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+
+      timerCleared = true;
+      clearInterval(liveLogInterval);
+      await new Promise(resolveFn => setImmediate(resolveFn));
+      console.log = originalLog;
+      process.stdout.write = originalStdoutWrite;
+      // Flush any remaining partial line
+      if (stdoutLineBuffer.trim()) {
+        logBuffer.push(stdoutLineBuffer.trim());
+        stdoutLineBuffer = '';
+      }
+
+      const finalLogs = logBuffer.join('\n');
+      originalStderrWrite(`📡 [Middleware] Sending final update for ${nodeName}: ${finalLogs.length} chars, ${logBuffer.length} total lines captured\n`);
+      if (result.success) {
+        await reportProgressFn(nodeName, 'success', finalLogs || `Completed in ${duration}s`, state);
+
+        // Send artifact for this node immediately (survives even if later nodes fail)
+        const extractor = NODE_ARTIFACT_MAP[nodeName];
+        if (extractor) {
+          const { key, value } = extractor(result);
+          if (value) {
+            await reportArtifactFn(state, key, value);
+          }
+        }
+      } else {
+        await reportProgressFn(nodeName, 'failed', `${finalLogs  }\n\nError: ${result.error}`, state);
+      }
+
+      return result;
+    } catch (error) {
+      timerCleared = true;
+      clearInterval(liveLogInterval);
+      await new Promise(resolveFn => setImmediate(resolveFn));
+      console.log = originalLog;
+      process.stdout.write = originalStdoutWrite;
+
+      const errorLogs = `${logBuffer.join('\n')  }\n\nError: ${error.message}`;
+      await reportProgressFn(nodeName, 'failed', errorLogs, state);
+      throw error;
+    }
+  };
+}
+
+/**
+ * Main analyze command
+ */
+export async function analyzeCommand(options) {
+  const {
+    EXECUTION_ID,
+    TICKET_KEY,
+    PROJECT_ID,
+    REPOS,
+    PROGRESS_QUEUE_URL,
+    PROGRESS_API_URL,
+    SQS_AUTH_TOKEN,
+    PROJECT_API_TOKEN,
+    GITHUB_TOKEN,
+    MODEL
+  } = process.env;
+
+  // Validate required env vars
+  if (!EXECUTION_ID || !TICKET_KEY || !PROJECT_ID) {
+    console.error('❌ Missing required environment variables');
+    console.error('   Required: EXECUTION_ID, TICKET_KEY, PROJECT_ID');
+    process.exit(1);
+  }
+
+  // Fetch large data (ticketContext, nodeConfigs) from DynamoDB instead of env vars
+  // This avoids the ECS 8192-char container overrides limit
+  const execCtx = await fetchExecutionContext(EXECUTION_ID, PROJECT_ID);
+  const ticketContext = execCtx.ticketContext;
+  let nodeConfigs = execCtx.nodeConfigs || {};
+  const repos = REPOS ? JSON.parse(REPOS) : execCtx.repos;
+  const workspace = process.env.WORKSPACE || '/workspace';
+  const promptsDir = join(dirname(dirname(dirname(__dirname))), 'core', 'templates', 'code-analysis', 'prompts');
+
+  console.log('\n🚀 Zibby Analysis (Graph Mode)');
+  console.log('─'.repeat(60));
+  console.log(`Ticket: ${TICKET_KEY}`);
+  console.log(`Repositories: ${repos.length}`);
+  console.log(`Workspace: ${workspace}`);
+  console.log(`AI Model: ${MODEL || 'auto'}`);
+  console.log('─'.repeat(60));
+
+  // Compile graph from: --workflow flag (local file) > S3 config > default
+  const logMiddleware = createLogCapturingMiddleware(reportProgress, reportArtifact);
+  let graphConfig;
+  let graphSource;
+
+  let jsWorkflowModule = null;
+
+  if (options?.workflow) {
+    const workflowPath = resolve(process.cwd(), options.workflow);
+    if (!existsSync(workflowPath)) {
+      console.error(`❌ Workflow file not found: ${workflowPath}`);
+      process.exit(1);
+    }
+
+    if (workflowPath.endsWith('.js') || workflowPath.endsWith('.mjs')) {
+      try {
+        const { pathToFileURL } = await import('url');
+        jsWorkflowModule = await import(pathToFileURL(workflowPath).href);
+        graphSource = `local JS module (${workflowPath})`;
+      } catch (err) {
+        console.error(`❌ Failed to load workflow JS module: ${err.message}`);
+        process.exit(1);
+      }
+    } else {
+      try {
+        const fileContent = JSON.parse(readFileSync(workflowPath, 'utf-8'));
+        const { _meta, ...config } = fileContent;
+        graphConfig = config;
+        graphSource = `local file (${workflowPath})`;
+      } catch (err) {
+        console.error(`❌ Failed to parse workflow file: ${err.message}`);
+        process.exit(1);
+      }
+      const validation = validateGraphConfig(graphConfig);
+      if (!validation.valid) {
+        console.error('❌ Invalid workflow file:');
+        validation.errors.forEach(e => console.error(`   - ${e}`));
+        process.exit(1);
+      }
+    }
+  } else if (execCtx.graphConfig) {
+    graphConfig = execCtx.graphConfig;
+    graphSource = 'custom (from project workflow)';
+  } else {
+    const graph = new WorkflowGraph();
+    buildAnalysisGraph(graph);
+    graphConfig = graph.serialize();
+    graphSource = 'default';
+  }
+
+  let graph;
+
+  if (jsWorkflowModule) {
+    const jsNodeConfigs = jsWorkflowModule.nodeConfigs || {};
+    const mergedNodeConfigs = { ...jsNodeConfigs, ...nodeConfigs };
+    graph = jsWorkflowModule.buildGraph({ nodeMiddleware: logMiddleware });
+    console.log(`📐 Graph source: ${graphSource}`);
+    console.log(`   Nodes: ${graph.nodes.size}`);
+    nodeConfigs = mergedNodeConfigs;
+  } else {
+    if (nodeConfigs && Object.keys(nodeConfigs).length > 0) {
+      const base = graphConfig.nodeConfigs || {};
+      const merged = { ...base };
+      for (const [nodeId, overrides] of Object.entries(nodeConfigs)) {
+        merged[nodeId] = { ...base[nodeId], ...overrides };
+      }
+      graphConfig.nodeConfigs = merged;
+    }
+
+    console.log(`📐 Graph source: ${graphSource}`);
+    console.log(`   Nodes: ${graphConfig.nodes?.length || 0}`);
+    console.log(`   Edges: ${graphConfig.edges?.length || 0}`);
+
+    graph = compileGraph(graphConfig, { nodeMiddleware: logMiddleware, stateSchema: analysisStateSchema });
+  }
+
+  // Write MCP config for any tools required by custom nodes (jira, slack_notify, github)
+  // Must be done before graph.run() so Cursor agent has MCP servers configured
+  writeMcpConfig(nodeConfigs);
+
+  // Execute graph
+  const initialState = {
+    EXECUTION_ID,
+    PROGRESS_QUEUE_URL,
+    PROGRESS_API_URL,
+    SQS_AUTH_TOKEN,
+    PROJECT_API_TOKEN,
+    workspace,
+    repos,
+    ticketContext,
+    promptsDir,
+    githubToken: GITHUB_TOKEN,
+    model: MODEL,
+    nodeConfigs
+  };
+
+  try {
+    const result = await graph.run(null, initialState);
+
+    // Artifacts are already sent per-node by the middleware (NODE_ARTIFACT_MAP).
+    // Here we only determine the final status and send it.
+    const finalState = result.state;
+    const validation = finalState.analyze_ticket_output?.validation
+      || finalState.analyze_ticket_output?.analysis?.structured?.validation;
+    let finalStatus = 'completed';
+    if (validation && !validation.canProceed) {
+      finalStatus = validation.status === 'insufficient_context' 
+        ? 'insufficient_context' 
+        : 'blocked';
+    }
+    console.log(`\n📋 Validation: canProceed=${validation?.canProceed}, status=${validation?.status}, finalStatus=${finalStatus}`);
+
+    console.log(`\n📊 Sending final status: ${finalStatus}`);
+    await reportFinalStatus(initialState, { status: finalStatus });
+
+    console.log('\n✅ Analysis completed successfully');
+    process.exit(0);
+  } catch (error) {
+    console.error('\n❌ Analysis failed:', error.message);
+    
+    if (EXECUTION_ID) {
+      try {
+        console.log(`📡 Reporting failure...`);
+        await reportFinalStatus(initialState, { status: 'failed', error: error.message });
+      } catch (_apiError) {
+        console.error('⚠️  Failed to report error');
+      }
+    }
+    
+    process.exit(1);
+  }
+}
+
+// Execute if run directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  analyzeCommand();
+}

package/src/commands/ci-setup.js

@@ -0,0 +1,65 @@
+import { patchCursorAgentForCI, checkCursorAgentPatched, getApprovalKeys, saveApprovalKeys } from '@zibby/core';
+import { resolve } from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+
+export async function ciSetupCommand(options) {
+  console.log(chalk.bold.cyan('\n🔧 Setting up CI/CD for Cursor Agent\n'));
+  console.log(chalk.gray('━'.repeat(50)));
+
+  const check = checkCursorAgentPatched();
+
+  if (!check.installed) {
+    console.log(chalk.red('\n❌ cursor-agent is not installed!\n'));
+    console.log(chalk.white('To install:'));
+    console.log(chalk.gray('  curl https://cursor.com/install -fsS | bash\n'));
+    process.exit(1);
+  }
+
+  if (check.patched) {
+    console.log(chalk.green('✅ cursor-agent is already patched for CI/CD\n'));
+  } else {
+    const spinner = ora('Patching cursor-agent...').start();
+
+    try {
+      await patchCursorAgentForCI();
+      spinner.succeed('cursor-agent patched successfully');
+    } catch (error) {
+      spinner.fail('Failed to patch cursor-agent');
+      console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+      process.exit(1);
+    }
+  }
+
+  if (options.getKeys) {
+    const spinner = ora('Getting approval keys...').start();
+
+    try {
+      const result = await getApprovalKeys(resolve(process.cwd()));
+      spinner.succeed('Approval keys retrieved');
+
+      console.log(chalk.cyan('\n📋 Approval Keys:\n'));
+      Object.entries(result.keys).forEach(([name, key]) => {
+        console.log(chalk.white(`  ${name}: ${chalk.gray(key)}`));
+      });
+
+      if (options.save) {
+        saveApprovalKeys(resolve(process.cwd()), result.keys);
+      } else {
+        console.log(chalk.gray('\nTo save these keys, run:'));
+        console.log(chalk.white('  zibby ci-setup --get-keys --save\n'));
+      }
+    } catch (error) {
+      spinner.fail('Failed to get approval keys');
+      console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+      process.exit(1);
+    }
+  }
+
+  console.log(chalk.green('\n✅ CI/CD setup complete!\n'));
+  console.log(chalk.cyan('Next steps:'));
+  console.log(chalk.white('  1. Get approval keys: zibby ci-setup --get-keys'));
+  console.log(chalk.white('  2. Save to project: zibby ci-setup --get-keys --save'));
+  console.log(chalk.white('  3. Use in CI: zibby run <spec> --agent=cursor --auto-approve\n'));
+}
+