wogiflow 1.0.0

package/scripts/hooks/core/session-context.js

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Session Context (Core Module)
+ *
+ * CLI-agnostic session context gathering.
+ * Gathers context to inject at session start.
+ *
+ * Returns a standardized result that adapters transform for specific CLIs.
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+// Import from parent scripts directory
+const { getConfig, PATHS, getReadyData } = require('../../flow-utils');
+
+/**
+ * Check if session context is enabled
+ * @returns {boolean}
+ */
+function isSessionContextEnabled() {
+  const config = getConfig();
+  return config.hooks?.rules?.sessionContext?.enabled !== false;
+}
+
+/**
+ * Get suspended task info
+ * @returns {Object|null} Suspended task info or null
+ */
+function getSuspendedTask() {
+  try {
+    const suspensionPath = path.join(PATHS.state, 'suspension.json');
+    if (!fs.existsSync(suspensionPath)) {
+      return null;
+    }
+
+    const suspension = JSON.parse(fs.readFileSync(suspensionPath, 'utf-8'));
+    if (!suspension.taskId || suspension.status === 'resumed') {
+      return null;
+    }
+
+    return suspension;
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Get current task in progress
+ * @returns {Object|null} Current task or null
+ */
+function getCurrentTask() {
+  try {
+    const readyData = getReadyData();
+    if (readyData.inProgress && readyData.inProgress.length > 0) {
+      const task = readyData.inProgress[0];
+      return typeof task === 'string' ? { id: task } : task;
+    }
+    return null;
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Get key decisions from decisions.md
+ * @param {number} maxEntries - Max number of decisions to return
+ * @returns {Array} Key decisions
+ */
+function getKeyDecisions(maxEntries = 5) {
+  try {
+    if (!fs.existsSync(PATHS.decisions)) {
+      return [];
+    }
+
+    const content = fs.readFileSync(PATHS.decisions, 'utf-8');
+    const decisions = [];
+
+    // Parse markdown sections
+    const sections = content.split(/^##\s+/m).slice(1);
+
+    for (const section of sections.slice(0, maxEntries)) {
+      const lines = section.split('\n');
+      const title = lines[0].trim();
+      const body = lines.slice(1).join('\n').trim();
+
+      if (title && body) {
+        decisions.push({
+          title,
+          summary: body.split('\n')[0].substring(0, 150)
+        });
+      }
+    }
+
+    return decisions;
+  } catch (err) {
+    return [];
+  }
+}
+
+/**
+ * Get recent activity from request log
+ * @param {number} maxEntries - Max entries to return
+ * @returns {Array} Recent activity
+ */
+function getRecentActivity(maxEntries = 3) {
+  try {
+    if (!fs.existsSync(PATHS.requestLog)) {
+      return [];
+    }
+
+    const content = fs.readFileSync(PATHS.requestLog, 'utf-8');
+    const entries = [];
+
+    // Parse request log entries (### R-XXX format)
+    const entryRegex = /^###\s+R-(\d+)\s*\|\s*(\d{4}-\d{2}-\d{2}[^]*?)(?=^###\s+R-|\Z)/gm;
+    let match;
+
+    while ((match = entryRegex.exec(content)) !== null && entries.length < maxEntries) {
+      const id = `R-${match[1]}`;
+      const body = match[2];
+
+      // Extract request line
+      const requestMatch = body.match(/\*\*Request\*\*:\s*"?([^"\n]+)"?/);
+      const request = requestMatch ? requestMatch[1] : 'Unknown';
+
+      entries.push({ id, request });
+    }
+
+    return entries.reverse(); // Most recent first
+  } catch (err) {
+    return [];
+  }
+}
+
+/**
+ * Get session state summary
+ * @returns {Object|null} Session state or null
+ */
+function getSessionState() {
+  try {
+    const sessionPath = path.join(PATHS.state, 'session-state.json');
+    if (!fs.existsSync(sessionPath)) {
+      return null;
+    }
+
+    const state = JSON.parse(fs.readFileSync(sessionPath, 'utf-8'));
+    return {
+      lastActive: state.lastActive,
+      recentFiles: (state.recentFiles || []).slice(0, 5),
+      recentDecisions: (state.recentDecisions || []).slice(0, 3)
+    };
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Gather all session context
+ * @param {Object} options
+ * @param {boolean} options.includeSuspended - Include suspended task info
+ * @param {boolean} options.includeDecisions - Include key decisions
+ * @param {boolean} options.includeActivity - Include recent activity
+ * @returns {Object} Session context
+ */
+function gatherSessionContext(options = {}) {
+  const config = getConfig();
+  const hookConfig = config.hooks?.rules?.sessionContext || {};
+
+  const {
+    includeSuspended = hookConfig.loadSuspendedTasks !== false,
+    includeDecisions = hookConfig.loadDecisions !== false,
+    includeActivity = hookConfig.loadRecentActivity !== false
+  } = options;
+
+  if (!isSessionContextEnabled()) {
+    return {
+      enabled: false,
+      context: null
+    };
+  }
+
+  const context = {
+    timestamp: new Date().toISOString(),
+    projectName: config.projectName || path.basename(PATHS.root)
+  };
+
+  // Suspended task
+  if (includeSuspended) {
+    const suspended = getSuspendedTask();
+    if (suspended) {
+      context.suspendedTask = {
+        taskId: suspended.taskId,
+        reason: suspended.reason,
+        resumeCondition: suspended.resumeCondition,
+        suspendedAt: suspended.suspendedAt
+      };
+    }
+  }
+
+  // Current task
+  const currentTask = getCurrentTask();
+  if (currentTask) {
+    context.currentTask = currentTask;
+  }
+
+  // Key decisions
+  if (includeDecisions) {
+    context.keyDecisions = getKeyDecisions(5);
+  }
+
+  // Recent activity
+  if (includeActivity) {
+    context.recentActivity = getRecentActivity(3);
+  }
+
+  // Session state
+  const sessionState = getSessionState();
+  if (sessionState) {
+    context.sessionState = sessionState;
+  }
+
+  return {
+    enabled: true,
+    context
+  };
+}
+
+/**
+ * Format context for injection into a session
+ * @param {Object} context - Context from gatherSessionContext
+ * @returns {string} Formatted context string
+ */
+function formatContextForInjection(context) {
+  if (!context || !context.context) {
+    return '';
+  }
+
+  const ctx = context.context;
+  let output = '## Wogi Flow Session Context\n\n';
+
+  // Suspended task alert
+  if (ctx.suspendedTask) {
+    output += `### Suspended Task\n`;
+    output += `Task **${ctx.suspendedTask.taskId}** is suspended.\n`;
+    output += `- Reason: ${ctx.suspendedTask.reason || 'Not specified'}\n`;
+    if (ctx.suspendedTask.resumeCondition) {
+      output += `- Resume condition: ${ctx.suspendedTask.resumeCondition}\n`;
+    }
+    output += `\nRun \`/wogi-resume\` to continue.\n\n`;
+  }
+
+  // Current task
+  if (ctx.currentTask) {
+    output += `### Current Task\n`;
+    output += `Working on: **${ctx.currentTask.id}**\n`;
+    if (ctx.currentTask.title) {
+      output += `Title: ${ctx.currentTask.title}\n`;
+    }
+    output += '\n';
+  }
+
+  // Key decisions
+  if (ctx.keyDecisions && ctx.keyDecisions.length > 0) {
+    output += `### Key Decisions\n`;
+    for (const decision of ctx.keyDecisions) {
+      output += `- **${decision.title}**: ${decision.summary}\n`;
+    }
+    output += '\n';
+  }
+
+  // Recent activity
+  if (ctx.recentActivity && ctx.recentActivity.length > 0) {
+    output += `### Recent Activity\n`;
+    for (const activity of ctx.recentActivity) {
+      output += `- ${activity.id}: ${activity.request}\n`;
+    }
+    output += '\n';
+  }
+
+  return output;
+}
+
+module.exports = {
+  isSessionContextEnabled,
+  getSuspendedTask,
+  getCurrentTask,
+  getKeyDecisions,
+  getRecentActivity,
+  getSessionState,
+  gatherSessionContext,
+  formatContextForInjection
+};

package/scripts/hooks/core/task-gate.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Task Gate (Core Module)
+ *
+ * CLI-agnostic task gating logic.
+ * Checks if there's an active task before allowing implementation actions.
+ *
+ * Returns a standardized result that adapters transform for specific CLIs.
+ */
+
+const path = require('path');
+
+// Import from parent scripts directory
+const { getConfig, getReadyData, findTask, PATHS } = require('../../flow-utils');
+
+/**
+ * Check if task gating should be enforced
+ * @returns {boolean}
+ */
+function isTaskGatingEnabled() {
+  const config = getConfig();
+
+  // Check hooks config first
+  if (config.hooks?.rules?.taskGating?.enabled === false) {
+    return false;
+  }
+
+  // Fall back to enforcement config
+  if (config.enforcement?.strictMode === false) {
+    return false;
+  }
+
+  if (config.enforcement?.requireTaskForImplementation === false) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Get the currently active task (if any)
+ * @returns {Object|null} Task object or null
+ */
+function getActiveTask() {
+  try {
+    const readyData = getReadyData();
+
+    // Check inProgress queue
+    if (readyData.inProgress && readyData.inProgress.length > 0) {
+      const task = readyData.inProgress[0];
+      return typeof task === 'string' ? { id: task } : task;
+    }
+
+    // Check durable session
+    const fs = require('fs');
+    const durableSessionPath = path.join(PATHS.state, 'durable-session.json');
+    if (fs.existsSync(durableSessionPath)) {
+      const session = JSON.parse(fs.readFileSync(durableSessionPath, 'utf-8'));
+      if (session.taskId && session.status === 'active') {
+        return { id: session.taskId, fromDurableSession: true };
+      }
+    }
+
+    return null;
+  } catch (err) {
+    // If we can't read state, assume no active task
+    return null;
+  }
+}
+
+/**
+ * Check task gating for an edit/write operation
+ *
+ * @param {Object} options
+ * @param {string} options.filePath - Path being edited/written
+ * @param {string} options.operation - 'edit' or 'write'
+ * @returns {Object} Result: { allowed, blocked, message, task }
+ */
+function checkTaskGate(options = {}) {
+  const { filePath, operation = 'edit' } = options;
+  // Exempt workflow state files from task gating
+  if (filePath && filePath.includes('.workflow/state/')) {
+    return {
+      allowed: true,
+      blocked: false,
+      message: null,
+      reason: 'workflow_state_exempt'
+    };
+  }
+
+  // Also exempt plan files
+  if (filePath && filePath.includes('.claude/plans/')) {
+    return {
+      allowed: true,
+      blocked: false,
+      message: null,
+      reason: 'plan_file_exempt'
+    };
+  }
+
+
+  // Check if gating is enabled
+  if (!isTaskGatingEnabled()) {
+    return {
+      allowed: true,
+      blocked: false,
+      message: null,
+      reason: 'task_gating_disabled'
+    };
+  }
+
+  // Check for active task
+  const activeTask = getActiveTask();
+
+  if (activeTask) {
+    return {
+      allowed: true,
+      blocked: false,
+      message: null,
+      task: activeTask,
+      reason: 'task_active'
+    };
+  }
+
+  // No active task - should we block?
+  const config = getConfig();
+  const shouldBlock = config.hooks?.rules?.taskGating?.blockWithoutTask !== false;
+
+  if (!shouldBlock) {
+    return {
+      allowed: true,
+      blocked: false,
+      message: generateWarningMessage(operation, filePath),
+      reason: 'warn_only'
+    };
+  }
+
+  // Block the operation
+  return {
+    allowed: false,
+    blocked: true,
+    message: generateBlockMessage(operation, filePath),
+    reason: 'no_active_task'
+  };
+}
+
+/**
+ * Generate warning message (when not blocking)
+ */
+function generateWarningMessage(operation, filePath) {
+  const fileName = filePath ? path.basename(filePath) : 'file';
+  return `Warning: ${operation === 'write' ? 'Creating' : 'Editing'} ${fileName} without an active task. Consider starting a task first.`;
+}
+
+/**
+ * Generate block message
+ */
+function generateBlockMessage(operation, filePath) {
+  const fileName = filePath ? path.basename(filePath) : 'file';
+  return `Cannot ${operation} ${fileName} without an active task.
+
+To proceed:
+1. Check available tasks: /wogi-ready
+2. Start an existing task: /wogi-start wf-XXXXXXXX
+3. Or create a new task: /wogi-story "description"
+
+Task gating is enforced when strictMode is enabled.`;
+}
+
+module.exports = {
+  isTaskGatingEnabled,
+  getActiveTask,
+  checkTaskGate,
+  generateBlockMessage,
+  generateWarningMessage
+};

package/scripts/hooks/core/validation.js

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Validation (Core Module)
+ *
+ * CLI-agnostic validation logic.
+ * Runs lint/typecheck after file edits.
+ *
+ * Returns a standardized result that adapters transform for specific CLIs.
+ */
+
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Import from parent scripts directory
+const { getConfig, PATHS } = require('../../flow-utils');
+
+/**
+ * Check if validation is enabled
+ * @returns {boolean}
+ */
+function isValidationEnabled() {
+  const config = getConfig();
+  return config.hooks?.rules?.validation?.enabled !== false;
+}
+
+/**
+ * Get validation commands for a file extension
+ * @param {string} ext - File extension (e.g., '.ts', '.tsx')
+ * @returns {string[]} Array of commands to run
+ */
+function getValidationCommands(ext) {
+  const config = getConfig();
+
+  // Check hooks config first
+  const hooksCommands = config.hooks?.rules?.validation?.commands;
+  if (hooksCommands && hooksCommands[`*${ext}`]) {
+    return hooksCommands[`*${ext}`];
+  }
+
+  // Fall back to validation.afterFileEdit config
+  const legacyCommands = config.validation?.afterFileEdit?.commands;
+  if (legacyCommands && legacyCommands[`*${ext}`]) {
+    return legacyCommands[`*${ext}`];
+  }
+
+  // Default commands by extension
+  const defaults = {
+    '.ts': ['npx tsc --noEmit'],
+    '.tsx': ['npx tsc --noEmit', 'npx eslint {file}'],
+    '.js': ['npx eslint {file}'],
+    '.jsx': ['npx eslint {file}']
+  };
+
+  return defaults[ext] || [];
+}
+
+/**
+ * Run a single validation command
+ * @param {string} command - Command to run (may contain {file} placeholder)
+ * @param {string} filePath - Path to the file being validated
+ * @param {number} timeout - Timeout in ms
+ * @returns {Promise<Object>} Result: { passed, output, error, duration }
+ */
+async function runValidationCommand(command, filePath, timeout = 30000) {
+  const startTime = Date.now();
+  const actualCommand = command.replace('{file}', `"${filePath}"`);
+
+  return new Promise((resolve) => {
+    try {
+      const result = execSync(actualCommand, {
+        cwd: PATHS.root,
+        encoding: 'utf-8',
+        timeout,
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+
+      resolve({
+        passed: true,
+        output: result,
+        error: null,
+        duration: Date.now() - startTime,
+        command: actualCommand
+      });
+    } catch (err) {
+      resolve({
+        passed: false,
+        output: err.stdout || '',
+        error: err.stderr || err.message,
+        duration: Date.now() - startTime,
+        command: actualCommand
+      });
+    }
+  });
+}
+
+/**
+ * Run all validation for a file
+ * @param {Object} options
+ * @param {string} options.filePath - Path to the file
+ * @param {number} options.timeout - Timeout per command in ms
+ * @returns {Promise<Object>} Result: { passed, results, summary }
+ */
+async function runValidation(options = {}) {
+  const { filePath, timeout = 30000 } = options;
+
+  if (!isValidationEnabled()) {
+    return {
+      passed: true,
+      skipped: true,
+      reason: 'validation_disabled',
+      results: []
+    };
+  }
+
+  const ext = path.extname(filePath);
+  const commands = getValidationCommands(ext);
+
+  if (commands.length === 0) {
+    return {
+      passed: true,
+      skipped: true,
+      reason: 'no_commands_for_extension',
+      extension: ext,
+      results: []
+    };
+  }
+
+  const results = [];
+  let allPassed = true;
+
+  for (const cmd of commands) {
+    const result = await runValidationCommand(cmd, filePath, timeout);
+    results.push(result);
+    if (!result.passed) {
+      allPassed = false;
+    }
+  }
+
+  return {
+    passed: allPassed,
+    skipped: false,
+    results,
+    summary: generateValidationSummary(results, filePath)
+  };
+}
+
+/**
+ * Generate human-readable validation summary
+ */
+function generateValidationSummary(results, filePath) {
+  const fileName = path.basename(filePath);
+  const passed = results.filter(r => r.passed).length;
+  const failed = results.filter(r => !r.passed).length;
+
+  if (failed === 0) {
+    return `Validation passed for ${fileName} (${passed} check${passed !== 1 ? 's' : ''})`;
+  }
+
+  let summary = `Validation failed for ${fileName}:\n`;
+  for (const result of results.filter(r => !r.passed)) {
+    summary += `\n- ${result.command}:\n`;
+    if (result.error) {
+      // Truncate long error output
+      const errorLines = result.error.split('\n').slice(0, 10);
+      summary += errorLines.map(line => `  ${line}`).join('\n');
+      if (result.error.split('\n').length > 10) {
+        summary += '\n  ... (truncated)';
+      }
+    }
+  }
+
+  return summary;
+}
+
+/**
+ * Parse TypeScript errors from output
+ * @param {string} output - TypeScript compiler output
+ * @returns {Array} Parsed errors
+ */
+function parseTypeScriptErrors(output) {
+  const errors = [];
+  const errorRegex = /(.+)\((\d+),(\d+)\):\s*error\s+(TS\d+):\s*(.+)/g;
+
+  let match;
+  while ((match = errorRegex.exec(output)) !== null) {
+    errors.push({
+      file: match[1],
+      line: parseInt(match[2], 10),
+      column: parseInt(match[3], 10),
+      code: match[4],
+      message: match[5]
+    });
+  }
+
+  return errors;
+}
+
+/**
+ * Parse ESLint errors from output
+ * @param {string} output - ESLint output
+ * @returns {Array} Parsed errors
+ */
+function parseEslintErrors(output) {
+  const errors = [];
+  const errorRegex = /(\d+):(\d+)\s+(error|warning)\s+(.+?)\s+(\S+)$/gm;
+
+  let match;
+  while ((match = errorRegex.exec(output)) !== null) {
+    errors.push({
+      line: parseInt(match[1], 10),
+      column: parseInt(match[2], 10),
+      severity: match[3],
+      message: match[4],
+      rule: match[5]
+    });
+  }
+
+  return errors;
+}
+
+module.exports = {
+  isValidationEnabled,
+  getValidationCommands,
+  runValidationCommand,
+  runValidation,
+  generateValidationSummary,
+  parseTypeScriptErrors,
+  parseEslintErrors
+};