wogiflow 1.0.13 → 1.0.15

package/lib/installer.js

@@ -477,8 +477,14 @@ async function init(args) {
   console.log('\n✅ Wogi Flow initialized successfully!\n');
   console.log('Next steps:');
   console.log('  1. Review .workflow/config.json');
-  console.log('  2. Run `./scripts/flow status` to see project status');
-  console.log('  3. Create your first task with `./scripts/flow story "Task title"`');
+  console.log('  2. Run `/wogi-status` to see project status');
+  console.log('  3. Create your first task with `/wogi-story "Task title"`');
+  console.log('');
+  console.log('Available commands:');
+  console.log('  /wogi-ready   - View available tasks');
+  console.log('  /wogi-status  - Project overview');
+  console.log('  /wogi-health  - Check workflow health');
+  console.log('  /wogi-story   - Create a new story');
   console.log('');
 }
 

package/lib/upgrader.js

@@ -393,7 +393,7 @@ async function upgrade(args) {
     console.log('\n✅ Upgrade complete!\n');
     console.log('Next steps:');
     console.log('  1. Review changes in .workflow/');
-    console.log('  2. Run `./scripts/flow health` to verify installation');
+    console.log('  2. Run `/wogi-health` to verify installation');
     console.log('  3. Commit the upgraded files');
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wogiflow",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "AI-powered development workflow management system with multi-model support",
   "main": "lib/index.js",
   "bin": {

package/scripts/flow

@@ -37,9 +37,8 @@ show_help() {
     echo "Usage: flow <command> [options]"
     echo ""
     echo "Setup & Updates:"
-    echo "  install              Interactive setup wizard"
-    echo "  install --quick      Quick setup with defaults"
-    echo "  onboard              Analyze existing project & set up context"
+    echo "  init                 Setup guide (directs to AI assistant)"
+    echo "  onboard              Project onboarding (directs to AI assistant)"
     echo "  migrate              Migrate to universal CLI-agnostic structure"
     echo "  migrate --dry-run    Preview migration without changes"
     echo "  update               Update to latest version (preserves data)"
@@ -383,12 +382,9 @@ case "${1:-}" in
     session-end)
         node "$SCRIPT_DIR/flow-session-end.js" "${@:2}"
         ;;
-    init)
+    init|install)
         "$SCRIPT_DIR/flow-init" "${@:2}"
         ;;
-    install)
-        "$SCRIPT_DIR/flow-install" "${@:2}"
-        ;;
     onboard)
         "$SCRIPT_DIR/flow-onboard" "${@:2}"
         ;;

package/scripts/flow-context-orchestrator.js

@@ -0,0 +1,475 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Context Orchestrator
+ *
+ * Enables targeted context loading for tasks using the PIN system.
+ * Supports orchestrator pattern where cheaper models (Haiku) gather
+ * relevant context for expensive models (Opus).
+ *
+ * Features:
+ * - PIN-based section lookup
+ * - Task description to relevant sections mapping
+ * - Token-aware context truncation
+ * - Product context integration
+ *
+ * Usage:
+ *   const { getTargetedContext } = require('./flow-context-orchestrator');
+ *   const context = await getTargetedContext({ task: "Add user auth" });
+ */
+
+const path = require('path');
+const {
+  PATHS,
+  fileExists,
+  readFile,
+  parseFlags,
+  outputJson,
+  info,
+  warn
+} = require('./flow-utils');
+
+const {
+  getSectionsForTask,
+  getSectionsByPins,
+  formatSectionsAsContext,
+  formatSectionsAsReferences
+} = require('./flow-section-resolver');
+
+// ============================================================
+// Configuration
+// ============================================================
+
+// Approximate tokens per character (conservative estimate)
+const CHARS_PER_TOKEN = 4;
+
+// Default limits
+const DEFAULT_MAX_TOKENS = 8000;
+const DEFAULT_SECTION_LIMIT = 10;
+
+// ============================================================
+// Token Estimation
+// ============================================================
+
+/**
+ * Estimate token count for a string
+ * @param {string} text - Text to estimate
+ * @returns {number} - Estimated token count
+ */
+function estimateTokens(text) {
+  if (!text) return 0;
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+
+/**
+ * Truncate sections to fit within token limit
+ * @param {Object[]} sections - Sections to truncate
+ * @param {number} maxTokens - Max tokens
+ * @returns {Object[]} - Truncated sections
+ */
+function truncateToTokenLimit(sections, maxTokens) {
+  const result = [];
+  let currentTokens = 0;
+
+  for (const section of sections) {
+    const sectionTokens = estimateTokens(section.content || '');
+
+    if (currentTokens + sectionTokens <= maxTokens) {
+      result.push(section);
+      currentTokens += sectionTokens;
+    } else if (result.length === 0) {
+      // Always include at least one section, even if truncated
+      const availableChars = (maxTokens - currentTokens) * CHARS_PER_TOKEN;
+      result.push({
+        ...section,
+        content: section.content?.substring(0, availableChars) + '...[truncated]',
+        truncated: true
+      });
+      break;
+    } else {
+      break;
+    }
+  }
+
+  return result;
+}
+
+// ============================================================
+// Section Merging
+// ============================================================
+
+/**
+ * Merge and deduplicate sections from multiple sources
+ * @param {Object[][]} sectionArrays - Arrays of sections to merge
+ * @returns {Object[]} - Merged and deduplicated sections
+ */
+function mergeSections(...sectionArrays) {
+  const seen = new Map();
+
+  for (const sections of sectionArrays) {
+    for (const section of sections) {
+      if (!seen.has(section.id)) {
+        seen.set(section.id, section);
+      } else {
+        // Keep the one with higher score
+        const existing = seen.get(section.id);
+        const existingScore = existing.score || existing.matchScore || 0;
+        const newScore = section.score || section.matchScore || 0;
+        if (newScore > existingScore) {
+          seen.set(section.id, section);
+        }
+      }
+    }
+  }
+
+  return Array.from(seen.values());
+}
+
+// ============================================================
+// Product Context
+// ============================================================
+
+/**
+ * Get product context from product.md
+ * @param {Object} options - { format: 'full' | 'summary' }
+ * @returns {Object|null} - Product context or null
+ */
+async function getProductContext(options = {}) {
+  const { format = 'summary' } = options;
+  const productPath = path.join(PATHS.specs, 'product.md');
+
+  if (!fileExists(productPath)) {
+    return null;
+  }
+
+  try {
+    // Get product sections via PINs
+    const productPins = ['product-name', 'target-users', 'value-prop', 'core-features'];
+    const sections = await getSectionsByPins(productPins, { limit: 5 });
+
+    if (sections.length === 0) {
+      // Fall back to reading the file directly
+      const content = readFile(productPath);
+      return {
+        context: content,
+        source: 'file',
+        tokenEstimate: estimateTokens(content)
+      };
+    }
+
+    const context = formatSectionsAsContext(sections, { format });
+    return {
+      context,
+      sections: sections.map(s => s.id),
+      source: 'pins',
+      tokenEstimate: estimateTokens(context)
+    };
+  } catch (err) {
+    warn(`Error loading product context: ${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * Get product overview (name, tagline, type only)
+ * @returns {Object|null} - Brief product info
+ */
+function getProductOverview() {
+  const productPath = path.join(PATHS.specs, 'product.md');
+
+  if (!fileExists(productPath)) {
+    return null;
+  }
+
+  try {
+    const content = readFile(productPath);
+
+    // Extract key fields using regex
+    const nameMatch = content.match(/\*\*Name\*\*:\s*(.+)/);
+    const taglineMatch = content.match(/\*\*Tagline\*\*:\s*(.+)/);
+    const typeMatch = content.match(/\*\*Type\*\*:\s*(.+)/);
+
+    return {
+      name: nameMatch ? nameMatch[1].trim() : null,
+      tagline: taglineMatch ? taglineMatch[1].trim() : null,
+      type: typeMatch ? typeMatch[1].trim() : null
+    };
+  } catch (err) {
+    return null;
+  }
+}
+
+// ============================================================
+// Main Context Gathering
+// ============================================================
+
+/**
+ * Get targeted context for a task
+ * @param {Object} options
+ * @param {string} options.task - Task description
+ * @param {string[]} options.pins - Explicit pins to include
+ * @param {number} options.maxTokens - Max tokens for context
+ * @param {string} options.format - 'full' | 'summary' | 'reference'
+ * @param {boolean} options.includeProduct - Include product context
+ * @returns {Object} - { context, sections, tokenEstimate }
+ */
+async function getTargetedContext(options = {}) {
+  const {
+    task = '',
+    pins = [],
+    maxTokens = DEFAULT_MAX_TOKENS,
+    format = 'full',
+    includeProduct = true
+  } = options;
+
+  const allSections = [];
+
+  // Get sections by task description
+  if (task) {
+    const taskSections = await getSectionsForTask(task, {
+      limit: DEFAULT_SECTION_LIMIT
+    });
+    allSections.push(...taskSections);
+  }
+
+  // Get sections by explicit pins
+  if (pins.length > 0) {
+    const pinSections = await getSectionsByPins(pins, {
+      limit: Math.floor(DEFAULT_SECTION_LIMIT / 2)
+    });
+    allSections.push(...pinSections);
+  }
+
+  // Merge and deduplicate
+  const mergedSections = mergeSections(allSections);
+
+  // Calculate available tokens for sections
+  let availableTokens = maxTokens;
+  let productContextResult = null;
+
+  // Include product context if requested
+  if (includeProduct) {
+    productContextResult = await getProductContext({ format: 'summary' });
+    if (productContextResult) {
+      availableTokens -= productContextResult.tokenEstimate;
+    }
+  }
+
+  // Truncate sections to fit
+  const truncatedSections = truncateToTokenLimit(mergedSections, availableTokens);
+
+  // Format sections
+  const sectionsContext = formatSectionsAsContext(truncatedSections, { format });
+
+  // Combine contexts
+  let fullContext = '';
+  if (productContextResult) {
+    fullContext += '## Product Context\n\n' + productContextResult.context + '\n\n';
+  }
+  if (sectionsContext) {
+    fullContext += sectionsContext;
+  }
+
+  return {
+    context: fullContext.trim(),
+    sections: truncatedSections.map(s => ({
+      id: s.id,
+      score: s.score || s.matchScore || 0,
+      truncated: s.truncated || false
+    })),
+    productIncluded: !!productContextResult,
+    tokenEstimate: estimateTokens(fullContext)
+  };
+}
+
+/**
+ * Get context for a specific task ID
+ * Loads task details and gathers relevant context
+ * @param {string} taskId - Task ID (e.g., "wf-abc123")
+ * @returns {Object} - Task context
+ */
+async function getContextForTaskId(taskId) {
+  // Try to find task in ready.json
+  const readyPath = path.join(PATHS.state, 'ready.json');
+  if (!fileExists(readyPath)) {
+    return getTargetedContext({ task: taskId });
+  }
+
+  try {
+    const ready = JSON.parse(readFile(readyPath));
+    const allTasks = [
+      ...(ready.ready || []),
+      ...(ready.inProgress || []),
+      ...(ready.blocked || [])
+    ];
+
+    const task = allTasks.find(t =>
+      (typeof t === 'string' && t === taskId) ||
+      (typeof t === 'object' && t.id === taskId)
+    );
+
+    if (task && typeof task === 'object' && task.title) {
+      return getTargetedContext({
+        task: `${task.title} ${task.description || ''}`,
+        pins: task.tags || []
+      });
+    }
+  } catch (err) {
+    // Fall back to using taskId as description
+  }
+
+  return getTargetedContext({ task: taskId });
+}
+
+/**
+ * Get minimal context references (for orchestrator hints)
+ * @param {string} task - Task description
+ * @returns {string} - Reference string
+ */
+async function getContextReferences(task) {
+  const sections = await getSectionsForTask(task, { limit: 5 });
+  return formatSectionsAsReferences(sections);
+}
+
+// ============================================================
+// CLI
+// ============================================================
+
+async function main() {
+  const { args, flags } = parseFlags(process.argv.slice(2));
+
+  if (flags.help) {
+    console.log(`
+Usage: node scripts/flow-context-orchestrator.js [command] [options]
+
+Get targeted context for tasks using the PIN system.
+
+Commands:
+  task "<description>"   Get context for a task description
+  taskid <id>            Get context for a task ID
+  product                Get product context only
+  refs "<description>"   Get section references only
+
+Options:
+  --max-tokens <n>       Max tokens for context (default: 8000)
+  --format <type>        Output format: full, summary, reference
+  --no-product           Exclude product context
+  --json                 Output as JSON
+  --help                 Show this help
+
+Examples:
+  node scripts/flow-context-orchestrator.js task "Add user authentication"
+  node scripts/flow-context-orchestrator.js taskid wf-abc123 --json
+  node scripts/flow-context-orchestrator.js product --format summary
+`);
+    process.exit(0);
+  }
+
+  const command = args[0];
+  const maxTokens = parseInt(flags['max-tokens']) || DEFAULT_MAX_TOKENS;
+  const format = flags.format || 'full';
+  const includeProduct = flags.product !== false;
+
+  switch (command) {
+    case 'task': {
+      const task = args.slice(1).join(' ');
+      if (!task) {
+        console.error('Usage: flow-context-orchestrator task "<description>"');
+        process.exit(1);
+      }
+
+      const result = await getTargetedContext({
+        task,
+        maxTokens,
+        format,
+        includeProduct
+      });
+
+      if (flags.json) {
+        outputJson(result);
+      } else {
+        console.log(result.context);
+        console.log(`\n--- ${result.sections.length} sections, ~${result.tokenEstimate} tokens ---`);
+      }
+      break;
+    }
+
+    case 'taskid': {
+      const taskId = args[1];
+      if (!taskId) {
+        console.error('Usage: flow-context-orchestrator taskid <id>');
+        process.exit(1);
+      }
+
+      const result = await getContextForTaskId(taskId);
+
+      if (flags.json) {
+        outputJson(result);
+      } else {
+        console.log(result.context);
+        console.log(`\n--- ${result.sections.length} sections, ~${result.tokenEstimate} tokens ---`);
+      }
+      break;
+    }
+
+    case 'product': {
+      const result = await getProductContext({ format });
+
+      if (!result) {
+        console.log('No product.md found');
+        process.exit(1);
+      }
+
+      if (flags.json) {
+        outputJson(result);
+      } else {
+        console.log(result.context);
+      }
+      break;
+    }
+
+    case 'refs': {
+      const task = args.slice(1).join(' ');
+      if (!task) {
+        console.error('Usage: flow-context-orchestrator refs "<description>"');
+        process.exit(1);
+      }
+
+      const refs = await getContextReferences(task);
+      console.log(refs || 'No relevant sections found');
+      break;
+    }
+
+    default:
+      console.error('Unknown command. Use --help for usage.');
+      process.exit(1);
+  }
+}
+
+// ============================================================
+// Exports
+// ============================================================
+
+module.exports = {
+  // Main functions
+  getTargetedContext,
+  getContextForTaskId,
+  getContextReferences,
+
+  // Product context
+  getProductContext,
+  getProductOverview,
+
+  // Utilities
+  estimateTokens,
+  truncateToTokenLimit,
+  mergeSections
+};
+
+// Run if called directly
+if (require.main === module) {
+  main().catch(err => {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  });
+}