wogiflow 1.0.11 → 1.0.13

package/scripts/flow-skill-create.js

@@ -5,6 +5,10 @@
  *
  * Creates new skills from templates with interactive prompts.
  *
+ * TODO: Consider consolidating with flow-skill-creator.js and
+ * flow-skill-generator.js into a single flow-skill.js with subcommands.
+ * See audit plan from 2026-01-12.
+ *
  * Usage:
  *   flow skill-create                  # Interactive mode
  *   flow skill-create <name>           # Create with name
@@ -76,14 +80,26 @@ function copyDirectory(src, dest, replacements = {}) {
 }
 
 async function createSkill(name, options = {}) {
-  const skillPath = path.join(SKILLS_DIR, name);
+  // Support nested paths like "frontend/react" or "backend/nestjs"
+  const pathParts = name.split('/').filter(Boolean);
+  const skillPath = path.join(SKILLS_DIR, ...pathParts);
+  const displayName = pathParts[pathParts.length - 1]; // Base name for display
 
   if (fs.existsSync(skillPath)) {
     log('red', `Skill '${name}' already exists at ${skillPath}`);
     return false;
   }
 
+  // Create parent directories if nested
+  if (pathParts.length > 1) {
+    const parentDir = path.join(SKILLS_DIR, ...pathParts.slice(0, -1));
+    fs.mkdirSync(parentDir, { recursive: true });
+  }
+
   log('cyan', `\n📦 Creating skill: ${name}\n`);
+  if (pathParts.length > 1) {
+    log('dim', `   (nested skill at ${skillPath})\n`);
+  }
 
   // Gather information
   const description = options.description || await prompt('Short description');
@@ -323,7 +339,7 @@ async function main() {
   await createSkill(name);
 }
 
-main().catch(e => {
-  log('red', `Error: ${e.message}`);
+main().catch(err => {
+  log('red', `Error: ${err.message}`);
   process.exit(1);
 });

package/scripts/flow-skill-matcher.js

@@ -23,6 +23,70 @@ const { getProjectRoot, getConfig, PATHS, colors } = require('./flow-utils');
 const PROJECT_ROOT = getProjectRoot();
 const SKILLS_DIR = path.join(PROJECT_ROOT, '.claude', 'skills');
 
+// Maximum nesting depth for skill directories (prevents runaway recursion)
+const MAX_SKILL_NESTING_DEPTH = 3;
+
+// ============================================================
+// Nested Skill Discovery
+// ============================================================
+
+/**
+ * Recursively discover all skills in the skills directory
+ * Looks for directories containing skill.md files
+ *
+ * @param {string} baseDir - Base directory to search
+ * @param {string} prefix - Path prefix for nested skills
+ * @param {number} depth - Current recursion depth
+ * @returns {string[]} Array of skill paths (e.g., ["nestjs", "frontend/react"])
+ */
+function discoverNestedSkills(baseDir = SKILLS_DIR, prefix = '', depth = 0) {
+  if (depth > MAX_SKILL_NESTING_DEPTH) {
+    return [];
+  }
+
+  const skills = [];
+
+  try {
+    if (!fs.existsSync(baseDir)) {
+      return [];
+    }
+
+    const entries = fs.readdirSync(baseDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      // Skip hidden directories, _template, and non-directories
+      if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name.startsWith('_')) {
+        continue;
+      }
+
+      const entryPath = path.join(baseDir, entry.name);
+      const skillPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+      const skillMdPath = path.join(entryPath, 'skill.md');
+
+      // If this directory has a skill.md, it's a skill
+      if (fs.existsSync(skillMdPath)) {
+        skills.push(skillPath);
+      }
+
+      // Recursively check subdirectories for more skills
+      const nestedSkills = discoverNestedSkills(entryPath, skillPath, depth + 1);
+      skills.push(...nestedSkills);
+    }
+  } catch (err) {
+    // Silently ignore permission errors, etc.
+  }
+
+  return skills;
+}
+
+/**
+ * Get the absolute path to a skill directory
+ * Handles both flat ("nestjs") and nested ("frontend/react") paths
+ */
+function getSkillDir(skillName) {
+  return path.join(SKILLS_DIR, ...skillName.split('/'));
+}
+
 // ============================================================
 // Skill Trigger Definitions
 // ============================================================
@@ -71,6 +135,7 @@ const DEFAULT_TRIGGERS = {
 /**
  * Load skill metadata from skill.md
  * Parses YAML frontmatter and extracts trigger configuration
+ * Supports both flat ("nestjs") and nested ("frontend/react") skill paths
  */
 function loadSkillMetadata(skillName) {
   // Skip template skills
@@ -78,7 +143,14 @@ function loadSkillMetadata(skillName) {
     return null;
   }
 
-  const skillPath = path.join(SKILLS_DIR, skillName, 'skill.md');
+  // Handle nested paths - get the base name for template checks
+  const baseName = skillName.split('/').pop();
+  if (baseName.startsWith('_')) {
+    return null;
+  }
+
+  const skillDir = getSkillDir(skillName);
+  const skillPath = path.join(skillDir, 'skill.md');
 
   if (!fs.existsSync(skillPath)) {
     return null;
@@ -206,15 +278,24 @@ function parseListSection(section) {
 
 /**
  * Get all installed skills with their triggers
+ * Combines skills from config.json with auto-discovered nested skills
  */
 function getAllSkills() {
   const config = getConfig();
-  const installedSkills = config.skills?.installed || [];
+  const configuredSkills = config.skills?.installed || [];
+  const autoDiscover = config.skills?.autoDiscoverNested !== false; // Default: true
   const skills = [];
+  const seenSkills = new Set();
+
+  // First, load configured skills (these take priority)
+  for (const skillName of configuredSkills) {
+    if (seenSkills.has(skillName)) continue;
+    seenSkills.add(skillName);
 
-  for (const skillName of installedSkills) {
     const metadata = loadSkillMetadata(skillName);
-    const defaultTriggers = DEFAULT_TRIGGERS[skillName] || {
+    // Get default triggers - check both full path and base name
+    const baseName = skillName.split('/').pop();
+    const defaultTriggers = DEFAULT_TRIGGERS[skillName] || DEFAULT_TRIGGERS[baseName] || {
       keywords: [],
       filePatterns: [],
       taskTypes: ['feature', 'bugfix', 'refactor'],
@@ -229,6 +310,35 @@ function getAllSkills() {
     });
   }
 
+  // Then, auto-discover nested skills if enabled
+  if (autoDiscover) {
+    const discoveredSkills = discoverNestedSkills();
+
+    for (const skillName of discoveredSkills) {
+      if (seenSkills.has(skillName)) continue;
+      seenSkills.add(skillName);
+
+      const metadata = loadSkillMetadata(skillName);
+      if (!metadata) continue; // Skip if can't load metadata
+
+      // Get default triggers - check both full path and base name
+      const baseName = skillName.split('/').pop();
+      const defaultTriggers = DEFAULT_TRIGGERS[skillName] || DEFAULT_TRIGGERS[baseName] || {
+        keywords: [],
+        filePatterns: [],
+        taskTypes: ['feature', 'bugfix', 'refactor'],
+        categories: []
+      };
+
+      skills.push({
+        name: skillName,
+        metadata: metadata || {},
+        triggers: metadata?.triggers || defaultTriggers,
+        filePatterns: metadata?.filePatterns || defaultTriggers.filePatterns
+      });
+    }
+  }
+
   return skills;
 }
 
@@ -323,11 +433,12 @@ function matchSkills(taskDescription, options = {}) {
 
 /**
  * Convert glob pattern to regex
+ * Uses [^/]* instead of .* to prevent matching directory separators (security)
  */
 function patternToRegex(pattern) {
   const escaped = pattern
     .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-    .replace(/\*/g, '.*')
+    .replace(/\*/g, '[^/]*')  // Security: don't match path separators
     .replace(/\?/g, '.');
   return new RegExp(escaped, 'i');
 }
@@ -360,7 +471,8 @@ async function loadSkillContext(matchedSkills, options = {}) {
   };
 
   for (const skill of skillsToLoad) {
-    const skillDir = path.join(SKILLS_DIR, skill.name);
+    // Use getSkillDir to handle nested paths
+    const skillDir = getSkillDir(skill.name);
     const skillContext = {
       name: skill.name,
       score: skill.score,
@@ -567,7 +679,10 @@ module.exports = {
   loadSkillContext,
   formatSkillContext,
   getSkillSummary,
-  DEFAULT_TRIGGERS
+  discoverNestedSkills,
+  getSkillDir,
+  DEFAULT_TRIGGERS,
+  MAX_SKILL_NESTING_DEPTH
 };
 
 if (require.main === module) {

package/scripts/flow-statusline-setup.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow - Status Line Setup
+ *
+ * Configures Claude Code's status line to show WogiFlow task information.
+ * Uses the new context_window.used_percentage field from Claude Code v1.0.52+.
+ *
+ * Usage:
+ *   flow statusline-setup           # Interactive setup
+ *   flow statusline-setup --format compact
+ *   flow statusline-setup --format detailed
+ *   flow statusline-setup --show    # Show current config
+ *   flow statusline-setup --disable # Disable status line
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+const { colors, printHeader, safeJsonParse } = require('./flow-utils');
+
+// Status line format presets
+const FORMATS = {
+  minimal: {
+    name: 'Minimal',
+    description: 'Just model and context percentage',
+    format: '{{model}} | {{context_window.used_percentage}}%'
+  },
+  compact: {
+    name: 'Compact',
+    description: 'Task ID + model + context',
+    format: '{{#if task}}[{{task.id}}] {{/if}}{{model}} | {{context_window.used_percentage}}%'
+  },
+  standard: {
+    name: 'Standard (Recommended)',
+    description: 'Task + model + labeled context',
+    format: '{{#if task}}[{{task.id}}] {{/if}}{{model}} | Ctx: {{context_window.used_percentage}}%'
+  },
+  detailed: {
+    name: 'Detailed',
+    description: 'Full info including skill',
+    format: '{{#if task}}[{{task.id}}] {{task.title}} | {{/if}}{{model}} | {{context_window.used_percentage}}% used{{#if skill}} | {{skill}}{{/if}}'
+  }
+};
+
+// Claude settings file location
+const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), '.claude', 'settings.json');
+
+function loadClaudeSettings() {
+  if (!fs.existsSync(CLAUDE_SETTINGS_PATH)) {
+    return {};
+  }
+  // Use safeJsonParse for prototype pollution protection
+  return safeJsonParse(CLAUDE_SETTINGS_PATH, {});
+}
+
+function saveClaudeSettings(settings) {
+  try {
+    // Ensure directory exists
+    const dir = path.dirname(CLAUDE_SETTINGS_PATH);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
+    return true;
+  } catch (err) {
+    console.error(`${colors.red}Error: Could not save Claude settings: ${err.message}${colors.reset}`);
+    return false;
+  }
+}
+
+function showCurrentConfig() {
+  const settings = loadClaudeSettings();
+  const statusLine = settings.statusLine || {};
+
+  printHeader('Current Status Line Configuration');
+
+  if (!statusLine.enabled && statusLine.enabled !== undefined) {
+    console.log(`${colors.dim}Status: ${colors.yellow}Disabled${colors.reset}`);
+  } else if (statusLine.format) {
+    console.log(`${colors.dim}Status: ${colors.green}Enabled${colors.reset}`);
+    console.log(`${colors.dim}Format:${colors.reset} ${statusLine.format}`);
+  } else {
+    console.log(`${colors.dim}Status: ${colors.yellow}Not configured${colors.reset}`);
+  }
+  console.log('');
+}
+
+function showFormats() {
+  console.log(`${colors.bold}Available Formats:${colors.reset}\n`);
+
+  for (const [key, preset] of Object.entries(FORMATS)) {
+    console.log(`  ${colors.cyan}${key}${colors.reset} - ${preset.name}`);
+    console.log(`    ${colors.dim}${preset.description}${colors.reset}`);
+    console.log(`    ${colors.dim}Preview: ${preset.format}${colors.reset}`);
+    console.log('');
+  }
+}
+
+async function interactiveSetup() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const question = (q) => new Promise(resolve => rl.question(q, resolve));
+
+  printHeader('Status Line Setup');
+  showCurrentConfig();
+  showFormats();
+
+  const format = await question(`\nChoose format (minimal/compact/standard/detailed) [standard]: `);
+  const selectedFormat = format.trim() || 'standard';
+
+  if (!FORMATS[selectedFormat]) {
+    console.log(`${colors.red}Invalid format: ${selectedFormat}${colors.reset}`);
+    rl.close();
+    process.exit(1);
+  }
+
+  const settings = loadClaudeSettings();
+  settings.statusLine = {
+    enabled: true,
+    format: FORMATS[selectedFormat].format
+  };
+
+  const confirm = await question(`\nApply "${FORMATS[selectedFormat].name}" format? (y/N): `);
+
+  if (confirm.toLowerCase() === 'y') {
+    if (saveClaudeSettings(settings)) {
+      console.log(`\n${colors.green}✓ Status line configured successfully!${colors.reset}`);
+      console.log(`${colors.dim}Restart Claude Code to see changes.${colors.reset}`);
+    }
+  } else {
+    console.log(`${colors.dim}Setup cancelled.${colors.reset}`);
+  }
+
+  rl.close();
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+Wogi Flow - Status Line Setup
+
+Configure Claude Code's status line to show task and context info.
+
+Usage:
+  flow statusline-setup             Interactive setup
+  flow statusline-setup --format X  Set format directly
+  flow statusline-setup --show      Show current config
+  flow statusline-setup --disable   Disable status line
+  flow statusline-setup --formats   List available formats
+
+Formats:
+  minimal   - Model + context %
+  compact   - Task ID + model + context %
+  standard  - Task ID + model + labeled context (recommended)
+  detailed  - Full info including skill name
+
+Examples:
+  flow statusline-setup --format standard
+  flow statusline-setup --format detailed
+`);
+    process.exit(0);
+  }
+
+  if (args.includes('--show')) {
+    showCurrentConfig();
+    process.exit(0);
+  }
+
+  if (args.includes('--formats')) {
+    showFormats();
+    process.exit(0);
+  }
+
+  if (args.includes('--disable')) {
+    const settings = loadClaudeSettings();
+    settings.statusLine = { enabled: false };
+    if (saveClaudeSettings(settings)) {
+      console.log(`${colors.green}✓ Status line disabled.${colors.reset}`);
+    }
+    process.exit(0);
+  }
+
+  const formatIndex = args.indexOf('--format');
+  if (formatIndex >= 0) {
+    const format = args[formatIndex + 1];
+    if (!format || !FORMATS[format]) {
+      console.log(`${colors.red}Invalid format. Use: minimal, compact, standard, or detailed${colors.reset}`);
+      process.exit(1);
+    }
+
+    const settings = loadClaudeSettings();
+    settings.statusLine = {
+      enabled: true,
+      format: FORMATS[format].format
+    };
+
+    if (saveClaudeSettings(settings)) {
+      console.log(`${colors.green}✓ Status line configured with "${format}" format.${colors.reset}`);
+      console.log(`${colors.dim}Restart Claude Code to see changes.${colors.reset}`);
+    }
+    process.exit(0);
+  }
+
+  // Default: interactive mode
+  await interactiveSetup();
+}
+
+main().catch(err => {
+  console.error(`${colors.red}Error: ${err.message}${colors.reset}`);
+  process.exit(1);
+});

package/scripts/flow-step-review.js

@@ -116,6 +116,25 @@ async function run(options = {}) {
     } catch (err) {
       // Auto-learn not available or failed - continue silently
     }
+
+    // Also capture to tech debt ledger for persistent tracking
+    try {
+      const { TechDebtManager } = require('./flow-tech-debt');
+      const debtManager = new TechDebtManager();
+      const { added, updated } = debtManager.addIssues(reportableIssues.map(issue => ({
+        file: issue.file,
+        line: issue.line,
+        category: issue.perspective || 'code',
+        severity: issue.severity === 'critical' ? 'critical' : (issue.severity === 'important' ? 'high' : 'medium'),
+        description: issue.description,
+        fix: issue.fix || ''
+      })));
+      if (added > 0 || updated > 0) {
+        console.log(colors.dim + `  Tech debt: ${added} new, ${updated} updated` + colors.reset);
+      }
+    } catch (err) {
+      // Tech debt manager not available or failed - continue silently
+    }
   }
 
   return {