agileflow 2.77.0 → 2.79.0

package/src/core/templates/skill-template.md

@@ -23,19 +23,45 @@ Include:
 - Key capabilities
 - Expected outcomes
 
+## Self-Improving Learnings
+
+This skill learns from your corrections and preferences.
+
+**On invocation**:
+1. Check if `.agileflow/skills/_learnings/{skill-name}.yaml` exists
+2. If exists, read and apply learned preferences
+3. Follow conventions and avoid anti-patterns from learnings
+
+**On correction**:
+1. When user corrects output, extract the signal
+2. Determine confidence level:
+   - **high**: Explicit correction ("never do X", "always do Y")
+   - **medium**: User approved or pattern worked well
+   - **low**: Observation to review later
+3. Update the learnings file with new preference
+
+**Learnings file location**: `.agileflow/skills/_learnings/{skill-name}.yaml`
+
 ## Instructions
 
 Step-by-step guidance for Claude:
 
-1. **First step**: What to do first
-   - Detail A
-   - Detail B
+1. **Load learnings** (if exists):
+   - Read `.agileflow/skills/_learnings/{skill-name}.yaml`
+   - Apply preferences, conventions, and anti-patterns
+   - Skip if file doesn't exist (first run)
 
-2. **Second step**: What to do next
-   - Detail A
-   - Detail B
+2. **Execute skill**:
+   - Follow the instructions below with learned preferences applied
+   - [Your skill-specific step A]
+   - [Your skill-specific step B]
+
+3. **If user corrects**:
+   - Extract signal from correction
+   - Update learnings file
+   - Continue with corrected approach
 
-3. **Final step**: How to complete the task
+4. **Final step**: Complete the task
    - Detail A
    - Detail B
 
@@ -50,9 +76,11 @@ Describe the expected output or deliverable:
 ## Quality Checklist
 
 Before completing, verify:
+- [ ] Loaded learnings file (if exists)
+- [ ] Applied learned preferences
 - [ ] Requirement 1 met
 - [ ] Requirement 2 met
-- [ ] Requirement 3 met
+- [ ] If corrected, updated learnings file
 
 ## Examples
 
@@ -68,8 +96,22 @@ Before completing, verify:
 [Example of what Claude should produce]
 ```
 
+### Example 2: Learning from Correction
+
+**User Correction:**
+```
+"Don't include emojis in the output"
+```
+
+**Self-Improve Action:**
+1. Extract signal: "User said 'Don't include emojis'"
+2. Learning: "Never include emojis in output"
+3. Confidence: high (explicit correction)
+4. Update `.agileflow/skills/_learnings/{skill-name}.yaml`
+
 ## Notes
 
-- Additional guidance or edge cases
-- Integration with other skills/commands
-- Important considerations
+- Learnings persist across sessions
+- First run has no learnings file - that's OK
+- High-confidence learnings are treated as rules
+- Git tracks learnings evolution over time

package/tools/cli/commands/start.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+
+/**
+ * AgileFlow TUI Dashboard
+ *
+ * BETA - Internal use only, not publicly documented
+ *
+ * Usage: npx agileflow start
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+// ANSI color codes
+const colors = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
+  orange: '\x1b[38;2;232;104;58m',
+  bgYellow: '\x1b[43m',
+  bgRed: '\x1b[41m',
+};
+
+function showBetaWarning() {
+  console.log('');
+  console.log(`${colors.bgYellow}${colors.bold}  BETA  ${colors.reset} ${colors.yellow}This feature is in beta and not yet stable${colors.reset}`);
+  console.log(`${colors.dim}        Expect bugs and incomplete features${colors.reset}`);
+  console.log('');
+}
+
+function showHeader() {
+  console.log(`${colors.orange}${colors.bold}`);
+  console.log('  ╔═══════════════════════════════════════════╗');
+  console.log('  ║         AgileFlow TUI Dashboard           ║');
+  console.log('  ╚═══════════════════════════════════════════╝');
+  console.log(`${colors.reset}`);
+}
+
+async function loadStatus() {
+  const statusPath = path.join(process.cwd(), 'docs', '09-agents', 'status.json');
+
+  if (!fs.existsSync(statusPath)) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(statusPath, 'utf8');
+    return JSON.parse(content);
+  } catch (err) {
+    return null;
+  }
+}
+
+function getStatusColor(status) {
+  switch (status) {
+    case 'completed':
+    case 'done':
+      return colors.green;
+    case 'in_progress':
+    case 'in-progress':
+      return colors.yellow;
+    case 'blocked':
+      return colors.red;
+    case 'ready':
+      return colors.cyan;
+    default:
+      return colors.dim;
+  }
+}
+
+function formatStory(story) {
+  const statusColor = getStatusColor(story.status);
+  const id = story.id || story.story_id || 'Unknown';
+  const title = story.title || story.summary || 'Untitled';
+  const status = (story.status || 'unknown').toUpperCase();
+  const owner = story.owner || '-';
+
+  return `  ${colors.bold}${id}${colors.reset} ${title.substring(0, 40)}${title.length > 40 ? '...' : ''}
+           ${statusColor}[${status}]${colors.reset} ${colors.dim}Owner: ${owner}${colors.reset}`;
+}
+
+async function showDashboard() {
+  showBetaWarning();
+  showHeader();
+
+  const status = await loadStatus();
+
+  if (!status) {
+    console.log(`${colors.dim}  No status.json found. Run /agileflow:story to create stories.${colors.reset}`);
+    console.log('');
+    return;
+  }
+
+  // Count stories by status
+  const stories = Object.values(status).filter(s => s && typeof s === 'object' && (s.id || s.story_id));
+  const counts = {
+    in_progress: stories.filter(s => ['in_progress', 'in-progress'].includes(s.status)).length,
+    blocked: stories.filter(s => s.status === 'blocked').length,
+    ready: stories.filter(s => s.status === 'ready').length,
+    completed: stories.filter(s => ['completed', 'done'].includes(s.status)).length,
+  };
+
+  const total = stories.length;
+  const completionPct = total > 0 ? Math.round((counts.completed / total) * 100) : 0;
+
+  // Summary
+  console.log(`${colors.bold}  Summary${colors.reset}`);
+  console.log(`  ────────────────────────────────────────────`);
+  console.log(`  ${colors.yellow}In Progress:${colors.reset} ${counts.in_progress}   ${colors.red}Blocked:${colors.reset} ${counts.blocked}   ${colors.cyan}Ready:${colors.reset} ${counts.ready}   ${colors.green}Done:${colors.reset} ${counts.completed}`);
+  console.log(`  ${colors.dim}Completion: ${completionPct}%${colors.reset}`);
+  console.log('');
+
+  // In Progress Stories
+  const inProgressStories = stories.filter(s => ['in_progress', 'in-progress'].includes(s.status));
+  if (inProgressStories.length > 0) {
+    console.log(`${colors.bold}  ${colors.yellow}In Progress${colors.reset}`);
+    console.log(`  ────────────────────────────────────────────`);
+    inProgressStories.forEach(story => {
+      console.log(formatStory(story));
+    });
+    console.log('');
+  }
+
+  // Blocked Stories
+  const blockedStories = stories.filter(s => s.status === 'blocked');
+  if (blockedStories.length > 0) {
+    console.log(`${colors.bold}  ${colors.red}Blocked${colors.reset}`);
+    console.log(`  ────────────────────────────────────────────`);
+    blockedStories.forEach(story => {
+      console.log(formatStory(story));
+    });
+    console.log('');
+  }
+
+  // Ready Stories (up to 5)
+  const readyStories = stories.filter(s => s.status === 'ready').slice(0, 5);
+  if (readyStories.length > 0) {
+    console.log(`${colors.bold}  ${colors.cyan}Ready for Work${colors.reset} ${colors.dim}(showing ${readyStories.length} of ${counts.ready})${colors.reset}`);
+    console.log(`  ────────────────────────────────────────────`);
+    readyStories.forEach(story => {
+      console.log(formatStory(story));
+    });
+    console.log('');
+  }
+
+  console.log(`${colors.dim}  Use /agileflow:board for interactive kanban view${colors.reset}`);
+  console.log(`${colors.dim}  Use /agileflow:story:list for full story list${colors.reset}`);
+  console.log('');
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  // Check for help flag
+  if (args.includes('--help') || args.includes('-h')) {
+    showBetaWarning();
+    console.log(`${colors.bold}AgileFlow TUI Dashboard${colors.reset}`);
+    console.log('');
+    console.log(`${colors.bold}Usage:${colors.reset}`);
+    console.log('  npx agileflow start           Show dashboard');
+    console.log('  npx agileflow start --help    Show this help');
+    console.log('');
+    console.log(`${colors.dim}This is a beta feature. For stable commands, use Claude Code slash commands.${colors.reset}`);
+    return;
+  }
+
+  await showDashboard();
+}
+
+main().catch(err => {
+  console.error(`${colors.red}Error:${colors.reset}`, err.message);
+  process.exit(1);
+});
+
+module.exports = { main };

package/tools/cli/installers/ide/claude-code.js

@@ -69,6 +69,9 @@ class ClaudeCodeSetup extends BaseIdeSetup {
     await this.ensureDir(skillsTargetDir);
     console.log(chalk.dim(`    - Skills directory: .claude/skills/ (for user-generated skills)`));
 
+    // Setup damage control hooks
+    await this.setupDamageControl(projectDir, agileflowDir, claudeDir, options);
+
     const totalCommands = commandResult.commands + agentResult.commands;
     const totalSubdirs =
       commandResult.subdirs + (agentResult.commands > 0 ? 1 : 0) + agentResult.subdirs;
@@ -86,6 +89,130 @@ class ClaudeCodeSetup extends BaseIdeSetup {
       subdirs: totalSubdirs,
     };
   }
+
+  /**
+   * Setup damage control hooks
+   * @param {string} projectDir - Project directory
+   * @param {string} agileflowDir - AgileFlow installation directory
+   * @param {string} claudeDir - .claude directory path
+   * @param {Object} options - Setup options
+   */
+  async setupDamageControl(projectDir, agileflowDir, claudeDir, options = {}) {
+    const damageControlSource = path.join(agileflowDir, 'scripts', 'damage-control');
+    const damageControlTarget = path.join(claudeDir, 'hooks', 'damage-control');
+
+    // Check if source exists
+    if (!fs.existsSync(damageControlSource)) {
+      console.log(chalk.dim(`    - Damage control: source not found, skipping`));
+      return;
+    }
+
+    // Create hooks directory
+    await this.ensureDir(damageControlTarget);
+
+    // Copy hook scripts
+    const scripts = ['bash-tool-damage-control.js', 'edit-tool-damage-control.js', 'write-tool-damage-control.js'];
+    for (const script of scripts) {
+      const src = path.join(damageControlSource, script);
+      const dest = path.join(damageControlTarget, script);
+      if (fs.existsSync(src)) {
+        await fs.copy(src, dest);
+      }
+    }
+
+    // Copy patterns.yaml (preserve existing)
+    const patternsSource = path.join(damageControlSource, 'patterns.yaml');
+    const patternsTarget = path.join(damageControlTarget, 'patterns.yaml');
+    if (fs.existsSync(patternsSource) && !fs.existsSync(patternsTarget)) {
+      await fs.copy(patternsSource, patternsTarget);
+      console.log(chalk.dim(`    - Damage control: patterns.yaml created`));
+    } else if (fs.existsSync(patternsTarget)) {
+      console.log(chalk.dim(`    - Damage control: patterns.yaml preserved`));
+    }
+
+    // Setup hooks in settings.json (unless disabled)
+    if (!options.skipDamageControl) {
+      await this.setupDamageControlHooks(claudeDir);
+      console.log(chalk.dim(`    - Damage control: hooks enabled`));
+    }
+  }
+
+  /**
+   * Add PreToolUse hooks to settings.json
+   * @param {string} claudeDir - .claude directory path
+   */
+  async setupDamageControlHooks(claudeDir) {
+    const settingsPath = path.join(claudeDir, 'settings.json');
+    let settings = {};
+
+    // Load existing settings
+    if (fs.existsSync(settingsPath)) {
+      try {
+        settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+      } catch (e) {
+        settings = {};
+      }
+    }
+
+    // Initialize hooks structure
+    if (!settings.hooks) settings.hooks = {};
+    if (!settings.hooks.PreToolUse) settings.hooks.PreToolUse = [];
+
+    // Define damage control hooks
+    const damageControlHooks = [
+      {
+        matcher: 'Bash',
+        hooks: [{
+          type: 'command',
+          command: 'node $CLAUDE_PROJECT_DIR/.claude/hooks/damage-control/bash-tool-damage-control.js',
+          timeout: 5000
+        }]
+      },
+      {
+        matcher: 'Edit',
+        hooks: [{
+          type: 'command',
+          command: 'node $CLAUDE_PROJECT_DIR/.claude/hooks/damage-control/edit-tool-damage-control.js',
+          timeout: 5000
+        }]
+      },
+      {
+        matcher: 'Write',
+        hooks: [{
+          type: 'command',
+          command: 'node $CLAUDE_PROJECT_DIR/.claude/hooks/damage-control/write-tool-damage-control.js',
+          timeout: 5000
+        }]
+      }
+    ];
+
+    // Merge with existing hooks (don't duplicate)
+    for (const newHook of damageControlHooks) {
+      const existingIdx = settings.hooks.PreToolUse.findIndex(h => h.matcher === newHook.matcher);
+      if (existingIdx === -1) {
+        // No existing matcher, add new
+        settings.hooks.PreToolUse.push(newHook);
+      } else {
+        // Existing matcher, merge hooks array
+        const existing = settings.hooks.PreToolUse[existingIdx];
+        if (!existing.hooks) existing.hooks = [];
+
+        // Check if damage control hook already exists
+        const dcHook = newHook.hooks[0];
+        const hasDcHook = existing.hooks.some(h =>
+          h.type === 'command' && h.command && h.command.includes('damage-control')
+        );
+
+        if (!hasDcHook) {
+          // Add at beginning for priority
+          existing.hooks.unshift(dcHook);
+        }
+      }
+    }
+
+    // Write settings
+    await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  }
 }
 
 module.exports = { ClaudeCodeSetup };

package/tools/cli/tui/Dashboard.js

@@ -0,0 +1,66 @@
+/**
+ * Dashboard Component
+ *
+ * BETA - Main TUI dashboard view
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+class Dashboard {
+  constructor(options = {}) {
+    this.statusPath = options.statusPath || path.join(process.cwd(), 'docs', '09-agents', 'status.json');
+    this.data = null;
+  }
+
+  async load() {
+    if (!fs.existsSync(this.statusPath)) {
+      return false;
+    }
+
+    try {
+      const content = fs.readFileSync(this.statusPath, 'utf8');
+      this.data = JSON.parse(content);
+      return true;
+    } catch (err) {
+      return false;
+    }
+  }
+
+  getStories() {
+    if (!this.data) return [];
+    return Object.values(this.data).filter(
+      s => s && typeof s === 'object' && (s.id || s.story_id)
+    );
+  }
+
+  getStats() {
+    const stories = this.getStories();
+    return {
+      total: stories.length,
+      in_progress: stories.filter(s => ['in_progress', 'in-progress'].includes(s.status)).length,
+      blocked: stories.filter(s => s.status === 'blocked').length,
+      ready: stories.filter(s => s.status === 'ready').length,
+      completed: stories.filter(s => ['completed', 'done'].includes(s.status)).length,
+    };
+  }
+
+  getCompletionPercentage() {
+    const stats = this.getStats();
+    if (stats.total === 0) return 0;
+    return Math.round((stats.completed / stats.total) * 100);
+  }
+
+  getStoriesByStatus(status) {
+    const stories = this.getStories();
+    if (status === 'in_progress') {
+      return stories.filter(s => ['in_progress', 'in-progress'].includes(s.status));
+    }
+    if (status === 'completed') {
+      return stories.filter(s => ['completed', 'done'].includes(s.status));
+    }
+    return stories.filter(s => s.status === status);
+  }
+}
+
+module.exports = Dashboard;

package/tools/cli/tui/StoryList.js

@@ -0,0 +1,69 @@
+/**
+ * StoryList Component
+ *
+ * BETA - Story list rendering for TUI
+ */
+
+class StoryList {
+  constructor(stories = []) {
+    this.stories = stories;
+    this.selectedIndex = 0;
+  }
+
+  setStories(stories) {
+    this.stories = stories;
+    this.selectedIndex = 0;
+  }
+
+  selectNext() {
+    if (this.selectedIndex < this.stories.length - 1) {
+      this.selectedIndex++;
+    }
+    return this.getSelected();
+  }
+
+  selectPrev() {
+    if (this.selectedIndex > 0) {
+      this.selectedIndex--;
+    }
+    return this.getSelected();
+  }
+
+  getSelected() {
+    return this.stories[this.selectedIndex] || null;
+  }
+
+  filter(predicate) {
+    return new StoryList(this.stories.filter(predicate));
+  }
+
+  sortByPriority() {
+    const priorityOrder = {
+      blocked: 0,
+      in_progress: 1,
+      'in-progress': 1,
+      ready: 2,
+      draft: 3,
+      completed: 4,
+      done: 4,
+    };
+
+    return new StoryList(
+      [...this.stories].sort((a, b) => {
+        const aPriority = priorityOrder[a.status] ?? 99;
+        const bPriority = priorityOrder[b.status] ?? 99;
+        return aPriority - bPriority;
+      })
+    );
+  }
+
+  toArray() {
+    return [...this.stories];
+  }
+
+  get length() {
+    return this.stories.length;
+  }
+}
+
+module.exports = StoryList;

package/tools/cli/tui/index.js

@@ -0,0 +1,16 @@
+/**
+ * AgileFlow TUI Components
+ *
+ * BETA - Internal use only, not publicly documented
+ *
+ * This module contains TUI components for the AgileFlow dashboard.
+ * Currently in early development.
+ */
+
+const Dashboard = require('./Dashboard');
+const StoryList = require('./StoryList');
+
+module.exports = {
+  Dashboard,
+  StoryList,
+};