claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/cli/simple-commands/init/sparc/roo-readme.js

@@ -1,7 +1,6 @@
 // roo-readme.js - README for .roo directory
-
 export function createRooReadme() {
-  return `# .roo Directory - SPARC Development Environment
+    return `# .roo Directory - SPARC Development Environment
 
 This directory contains the SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) development environment configuration and templates.
 

package/dist/src/cli/simple-commands/init/sparc/roomodes-config.js

@@ -1,102 +1,125 @@
 // roomodes-config.js - Basic .roomodes configuration
-
 export function createBasicRoomodesConfig() {
-  return JSON.stringify(
-    {
-      customModes: [
-        {
-          slug: 'architect',
-          name: '🏗️ Architect',
-          roleDefinition:
-            'You design scalable, secure, and modular architectures based on functional specs and user needs. You define responsibilities across services, APIs, and components.',
-          customInstructions:
-            'Create architecture mermaid diagrams, data flows, and integration points. Ensure no part of the design includes secrets or hardcoded env values. Emphasize modular boundaries and maintain extensibility.',
-          groups: ['read', 'edit'],
-          source: 'project',
-        },
-        {
-          slug: 'code',
-          name: '🧠 Auto-Coder',
-          roleDefinition:
-            'You write clean, efficient, modular code based on pseudocode and architecture. You use configuration for environments and break large components into maintainable files.',
-          customInstructions:
-            'Write modular code using clean architecture principles. Never hardcode secrets or environment values. Split code into files < 500 lines. Use config files or environment abstractions. Use `new_task` for subtasks and finish with `attempt_completion`.',
-          groups: ['read', 'edit', 'browser', 'mcp', 'command'],
-          source: 'project',
-        },
-        {
-          slug: 'tdd',
-          name: '🧪 Tester (TDD)',
-          roleDefinition:
-            'You implement Test-Driven Development (TDD, London School), writing tests first and refactoring after minimal implementation passes.',
-          customInstructions:
-            'Write failing tests first. Implement only enough code to pass. Refactor after green. Ensure tests do not hardcode secrets. Keep files < 500 lines.',
-          groups: ['read', 'edit', 'browser', 'mcp', 'command'],
-          source: 'project',
-        },
-        {
-          slug: 'spec-pseudocode',
-          name: '📋 Specification Writer',
-          roleDefinition:
-            'You capture full project context—functional requirements, edge cases, constraints—and translate that into modular pseudocode with TDD anchors.',
-          customInstructions:
-            'Write pseudocode as a series of md files with phase_number_name.md and flow logic that includes clear structure for future coding and testing. Split complex logic across modules.',
-          groups: ['read', 'edit'],
-          source: 'project',
-        },
-        {
-          slug: 'integration',
-          name: '🔗 System Integrator',
-          roleDefinition:
-            'You merge the outputs of all modes into a working, tested, production-ready system. You ensure consistency, cohesion, and modularity.',
-          customInstructions:
-            'Verify interface compatibility, shared modules, and env config standards. Split integration logic across domains as needed. Use `new_task` for preflight testing.',
-          groups: ['read', 'edit', 'browser', 'mcp', 'command'],
-          source: 'project',
-        },
-        {
-          slug: 'debug',
-          name: '🪲 Debugger',
-          roleDefinition:
-            'You troubleshoot runtime bugs, logic errors, or integration failures by tracing, inspecting, and analyzing behavior.',
-          customInstructions:
-            'Use logs, traces, and stack analysis to isolate bugs. Avoid changing env configuration directly. Keep fixes modular.',
-          groups: ['read', 'edit', 'browser', 'mcp', 'command'],
-          source: 'project',
-        },
-        {
-          slug: 'security-review',
-          name: '🛡️ Security Reviewer',
-          roleDefinition:
-            'You perform static and dynamic audits to ensure secure code practices. You flag secrets, poor modular boundaries, and oversized files.',
-          customInstructions:
-            'Scan for exposed secrets, env leaks, and monoliths. Recommend mitigations or refactors to reduce risk. Flag files > 500 lines or direct environment coupling.',
-          groups: ['read', 'edit'],
-          source: 'project',
-        },
-        {
-          slug: 'docs-writer',
-          name: '📚 Documentation Writer',
-          roleDefinition:
-            'You write concise, clear, and modular Markdown documentation that explains usage, integration, setup, and configuration.',
-          customInstructions:
-            'Only work in .md files. Use sections, examples, and headings. Keep each file under 500 lines. Do not leak env values.',
-          groups: ['read', ['edit', { fileRegex: '\\.md$', description: 'Markdown files only' }]],
-          source: 'project',
-        },
-        {
-          slug: 'swarm',
-          name: '🐝 Swarm Coordinator',
-          roleDefinition:
-            'You are the swarm coordination specialist, orchestrating multiple AI agents to handle complex, long-running tasks that would be difficult or impossible for a single agent due to scope, complexity, or timeout constraints.',
-          customInstructions:
-            'Coordinate advanced multi-agent swarms with timeout-free execution capabilities. Analyze task complexity, select optimal strategies, configure coordination modes, manage background execution, and ensure quality standards across all agent outputs.',
-          groups: ['read', 'edit', 'command'],
-          source: 'project',
-        },
-      ],
-    },
-    null,
-    2,
-  );
+    return JSON.stringify({
+        customModes: [
+            {
+                slug: 'architect',
+                name: '🏗️ Architect',
+                roleDefinition: 'You design scalable, secure, and modular architectures based on functional specs and user needs. You define responsibilities across services, APIs, and components.',
+                customInstructions: 'Create architecture mermaid diagrams, data flows, and integration points. Ensure no part of the design includes secrets or hardcoded env values. Emphasize modular boundaries and maintain extensibility.',
+                groups: [
+                    'read',
+                    'edit'
+                ],
+                source: 'project'
+            },
+            {
+                slug: 'code',
+                name: '🧠 Auto-Coder',
+                roleDefinition: 'You write clean, efficient, modular code based on pseudocode and architecture. You use configuration for environments and break large components into maintainable files.',
+                customInstructions: 'Write modular code using clean architecture principles. Never hardcode secrets or environment values. Split code into files < 500 lines. Use config files or environment abstractions. Use `new_task` for subtasks and finish with `attempt_completion`.',
+                groups: [
+                    'read',
+                    'edit',
+                    'browser',
+                    'mcp',
+                    'command'
+                ],
+                source: 'project'
+            },
+            {
+                slug: 'tdd',
+                name: '🧪 Tester (TDD)',
+                roleDefinition: 'You implement Test-Driven Development (TDD, London School), writing tests first and refactoring after minimal implementation passes.',
+                customInstructions: 'Write failing tests first. Implement only enough code to pass. Refactor after green. Ensure tests do not hardcode secrets. Keep files < 500 lines.',
+                groups: [
+                    'read',
+                    'edit',
+                    'browser',
+                    'mcp',
+                    'command'
+                ],
+                source: 'project'
+            },
+            {
+                slug: 'spec-pseudocode',
+                name: '📋 Specification Writer',
+                roleDefinition: 'You capture full project context—functional requirements, edge cases, constraints—and translate that into modular pseudocode with TDD anchors.',
+                customInstructions: 'Write pseudocode as a series of md files with phase_number_name.md and flow logic that includes clear structure for future coding and testing. Split complex logic across modules.',
+                groups: [
+                    'read',
+                    'edit'
+                ],
+                source: 'project'
+            },
+            {
+                slug: 'integration',
+                name: '🔗 System Integrator',
+                roleDefinition: 'You merge the outputs of all modes into a working, tested, production-ready system. You ensure consistency, cohesion, and modularity.',
+                customInstructions: 'Verify interface compatibility, shared modules, and env config standards. Split integration logic across domains as needed. Use `new_task` for preflight testing.',
+                groups: [
+                    'read',
+                    'edit',
+                    'browser',
+                    'mcp',
+                    'command'
+                ],
+                source: 'project'
+            },
+            {
+                slug: 'debug',
+                name: '🪲 Debugger',
+                roleDefinition: 'You troubleshoot runtime bugs, logic errors, or integration failures by tracing, inspecting, and analyzing behavior.',
+                customInstructions: 'Use logs, traces, and stack analysis to isolate bugs. Avoid changing env configuration directly. Keep fixes modular.',
+                groups: [
+                    'read',
+                    'edit',
+                    'browser',
+                    'mcp',
+                    'command'
+                ],
+                source: 'project'
+            },
+            {
+                slug: 'security-review',
+                name: '🛡️ Security Reviewer',
+                roleDefinition: 'You perform static and dynamic audits to ensure secure code practices. You flag secrets, poor modular boundaries, and oversized files.',
+                customInstructions: 'Scan for exposed secrets, env leaks, and monoliths. Recommend mitigations or refactors to reduce risk. Flag files > 500 lines or direct environment coupling.',
+                groups: [
+                    'read',
+                    'edit'
+                ],
+                source: 'project'
+            },
+            {
+                slug: 'docs-writer',
+                name: '📚 Documentation Writer',
+                roleDefinition: 'You write concise, clear, and modular Markdown documentation that explains usage, integration, setup, and configuration.',
+                customInstructions: 'Only work in .md files. Use sections, examples, and headings. Keep each file under 500 lines. Do not leak env values.',
+                groups: [
+                    'read',
+                    [
+                        'edit',
+                        {
+                            fileRegex: '\\.md$',
+                            description: 'Markdown files only'
+                        }
+                    ]
+                ],
+                source: 'project'
+            },
+            {
+                slug: 'swarm',
+                name: '🐝 Swarm Coordinator',
+                roleDefinition: 'You are the swarm coordination specialist, orchestrating multiple AI agents to handle complex, long-running tasks that would be difficult or impossible for a single agent due to scope, complexity, or timeout constraints.',
+                customInstructions: 'Coordinate advanced multi-agent swarms with timeout-free execution capabilities. Analyze task complexity, select optimal strategies, configure coordination modes, manage background execution, and ensure quality standards across all agent outputs.',
+                groups: [
+                    'read',
+                    'edit',
+                    'command'
+                ],
+                source: 'project'
+            }
+        ]
+    }, null, 2);
 }

package/dist/src/cli/simple-commands/init/sparc/workflows.js

@@ -1,40 +1,35 @@
 // workflows.js - SPARC workflow templates
-
 export function createBasicSparcWorkflow() {
-  return JSON.stringify(
-    {
-      name: 'Basic TDD Workflow',
-      description: 'A simple SPARC-based TDD workflow for development',
-      sequential: true,
-      steps: [
-        {
-          mode: 'spec-pseudocode',
-          description: 'Create detailed specifications and pseudocode',
-          phase: 'specification',
-        },
-        {
-          mode: 'tdd',
-          description: 'Write failing tests (Red phase)',
-          phase: 'red',
-        },
-        {
-          mode: 'code',
-          description: 'Implement minimal code to pass tests (Green phase)',
-          phase: 'green',
-        },
-        {
-          mode: 'tdd',
-          description: 'Refactor and optimize (Refactor phase)',
-          phase: 'refactor',
-        },
-        {
-          mode: 'integration',
-          description: 'Integrate and verify complete solution',
-          phase: 'integration',
-        },
-      ],
-    },
-    null,
-    2,
-  );
+    return JSON.stringify({
+        name: 'Basic TDD Workflow',
+        description: 'A simple SPARC-based TDD workflow for development',
+        sequential: true,
+        steps: [
+            {
+                mode: 'spec-pseudocode',
+                description: 'Create detailed specifications and pseudocode',
+                phase: 'specification'
+            },
+            {
+                mode: 'tdd',
+                description: 'Write failing tests (Red phase)',
+                phase: 'red'
+            },
+            {
+                mode: 'code',
+                description: 'Implement minimal code to pass tests (Green phase)',
+                phase: 'green'
+            },
+            {
+                mode: 'tdd',
+                description: 'Refactor and optimize (Refactor phase)',
+                phase: 'refactor'
+            },
+            {
+                mode: 'integration',
+                description: 'Integrate and verify complete solution',
+                phase: 'integration'
+            }
+        ]
+    }, null, 2);
 }

package/dist/src/cli/simple-commands/init/sparc-structure.js

@@ -1,68 +1,61 @@
 // sparc-structure.js - Create SPARC development structure
-
-import { createBasicRoomodesConfig } from './sparc/roomodes-config.js';
-import { errors } from '../../node-compat.js';
-import { promises as fs } from 'fs';
-import { createBasicSparcWorkflow } from './sparc/workflows.js';
-import { createRooReadme } from './sparc/roo-readme.js';
-import { createClaudeSlashCommands } from './claude-commands/slash-commands.js';
-import { cwd } from '../../node-compat.js';
-import process from 'process';
-
+import { createBasicRoomodesConfig } from "./sparc/roomodes-config.js";
+import { errors } from "../../node-compat.js";
+import { promises as fs } from "fs";
+import { createBasicSparcWorkflow } from "./sparc/workflows.js";
+import { createRooReadme } from "./sparc/roo-readme.js";
+import { createClaudeSlashCommands } from "./claude-commands/slash-commands.js";
+import { cwd } from "../../node-compat.js";
+import process from "process";
 // Helper function to create SPARC structure manually
 export async function createSparcStructureManually() {
-  try {
-    // Ensure we're in the working directory
-    const workingDir = process.env.PWD || cwd();
-
-    // Create .roo directory structure in working directory (legacy support)
-    const rooDirectories = [
-      `${workingDir}/.roo`,
-      `${workingDir}/.roo/templates`,
-      `${workingDir}/.roo/workflows`,
-      `${workingDir}/.roo/modes`,
-      `${workingDir}/.roo/configs`,
-    ];
-
-    for (const dir of rooDirectories) {
-      try {
-        await fs.mkdir(dir, { recursive: true });
-        console.log(`  ✓ Created ${dir}/`);
-      } catch (err) {
-        if (!(err instanceof errors.AlreadyExists)) {
-          throw err;
-        }
-      }
-    }
-
-    // Create .roomodes file (copy from existing if available, or create basic version)
-    let roomodesContent;
     try {
-      // Check if .roomodes already exists and read it
-      roomodesContent = await fs.readFile(`${workingDir}/.roomodes`, 'utf8');
-      console.log('  ✓ Using existing .roomodes configuration');
-    } catch {
-      // Create basic .roomodes configuration
-      roomodesContent = createBasicRoomodesConfig();
-      await fs.writeFile(`${workingDir}/.roomodes`, roomodesContent, 'utf8');
-      console.log('  ✓ Created .roomodes configuration');
+        // Ensure we're in the working directory
+        const workingDir = process.env.PWD || cwd();
+        // Create .roo directory structure in working directory (legacy support)
+        const rooDirectories = [
+            `${workingDir}/.roo`,
+            `${workingDir}/.roo/templates`,
+            `${workingDir}/.roo/workflows`,
+            `${workingDir}/.roo/modes`,
+            `${workingDir}/.roo/configs`
+        ];
+        for (const dir of rooDirectories){
+            try {
+                await fs.mkdir(dir, {
+                    recursive: true
+                });
+                console.log(`  ✓ Created ${dir}/`);
+            } catch (err) {
+                if (!(err instanceof errors.AlreadyExists)) {
+                    throw err;
+                }
+            }
+        }
+        // Create .roomodes file (copy from existing if available, or create basic version)
+        let roomodesContent;
+        try {
+            // Check if .roomodes already exists and read it
+            roomodesContent = await fs.readFile(`${workingDir}/.roomodes`, 'utf8');
+            console.log('  ✓ Using existing .roomodes configuration');
+        } catch  {
+            // Create basic .roomodes configuration
+            roomodesContent = createBasicRoomodesConfig();
+            await fs.writeFile(`${workingDir}/.roomodes`, roomodesContent, 'utf8');
+            console.log('  ✓ Created .roomodes configuration');
+        }
+        // Create basic workflow templates
+        const basicWorkflow = createBasicSparcWorkflow();
+        await fs.writeFile(`${workingDir}/.roo/workflows/basic-tdd.json`, basicWorkflow, 'utf8');
+        console.log('  ✓ Created .roo/workflows/basic-tdd.json');
+        // Create README for .roo directory
+        const rooReadme = createRooReadme();
+        await fs.writeFile(`${workingDir}/.roo/README.md`, rooReadme, 'utf8');
+        console.log('  ✓ Created .roo/README.md');
+        // Create Claude Code slash commands for SPARC modes
+        await createClaudeSlashCommands(workingDir);
+        console.log('  ✅ Basic SPARC structure created successfully');
+    } catch (err) {
+        console.log(`  ❌ Failed to create SPARC structure: ${err.message}`);
     }
-
-    // Create basic workflow templates
-    const basicWorkflow = createBasicSparcWorkflow();
-    await fs.writeFile(`${workingDir}/.roo/workflows/basic-tdd.json`, basicWorkflow, 'utf8');
-    console.log('  ✓ Created .roo/workflows/basic-tdd.json');
-
-    // Create README for .roo directory
-    const rooReadme = createRooReadme();
-    await fs.writeFile(`${workingDir}/.roo/README.md`, rooReadme, 'utf8');
-    console.log('  ✓ Created .roo/README.md');
-
-    // Create Claude Code slash commands for SPARC modes
-    await createClaudeSlashCommands(workingDir);
-
-    console.log('  ✅ Basic SPARC structure created successfully');
-  } catch (err) {
-    console.log(`  ❌ Failed to create SPARC structure: ${err.message}`);
-  }
 }