@bradygaster/squad-sdk 0.7.0 → 0.8.2-1.4

package/dist/config/init.js

@@ -0,0 +1,807 @@
+/**
+ * Squad Initialization Module (M2-6, PRD #98)
+ *
+ * Creates new Squad projects with typed configuration.
+ * Generates squad.config.ts or squad.config.json with agent definitions.
+ * Scaffolds directory structure, templates, workflows, and agent files.
+ *
+ * @module config/init
+ */
+import { mkdir, writeFile, appendFile, unlink } from 'fs/promises';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync, cpSync, statSync, mkdirSync, readFileSync, readdirSync } from 'fs';
+import { MODELS } from '../runtime/constants.js';
+// ============================================================================
+// Template Resolution
+// ============================================================================
+/**
+ * Get the SDK templates directory path.
+ */
+export function getSDKTemplatesDir() {
+    // Use fileURLToPath for cross-platform compatibility (handles Windows drive letters, URL encoding)
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    // Try relative to this file (in dist/)
+    const distPath = join(currentDir, '../../templates');
+    if (existsSync(distPath)) {
+        return distPath;
+    }
+    // Try relative to package root (for dev)
+    const pkgPath = join(currentDir, '../../../templates');
+    if (existsSync(pkgPath)) {
+        return pkgPath;
+    }
+    return null;
+}
+/**
+ * Copy a directory recursively.
+ */
+function copyRecursiveSync(src, dest) {
+    if (!existsSync(dest)) {
+        mkdirSync(dest, { recursive: true });
+    }
+    for (const entry of statSync(src).isDirectory() ? readdirSync(src) : []) {
+        const srcPath = join(src, entry);
+        const destPath = join(dest, entry);
+        if (statSync(srcPath).isDirectory()) {
+            copyRecursiveSync(srcPath, destPath);
+        }
+        else {
+            cpSync(srcPath, destPath);
+        }
+    }
+}
+// ============================================================================
+// Default Agent Templates
+// ============================================================================
+/**
+ * Default agent templates for common roles.
+ */
+const AGENT_TEMPLATES = {
+    'lead': {
+        displayName: 'Lead',
+        description: 'Technical lead responsible for architecture, delegation, and project coordination.'
+    },
+    'developer': {
+        displayName: 'Developer',
+        description: 'Software developer focused on feature implementation and code quality.'
+    },
+    'tester': {
+        displayName: 'Tester',
+        description: 'Quality assurance specialist responsible for test coverage and validation.'
+    },
+    'scribe': {
+        displayName: 'Scribe',
+        description: 'Documentation specialist maintaining history, decisions, and technical records.'
+    },
+    'ralph': {
+        displayName: 'Ralph',
+        description: 'Persistent memory agent that maintains context across sessions.'
+    }
+};
+// ============================================================================
+// Configuration Templates
+// ============================================================================
+/**
+ * Format a readonly string array as a single-quoted TypeScript array literal.
+ */
+function formatModelArray(chain) {
+    return `[${chain.map(m => `'${m}'`).join(', ')}]`;
+}
+/**
+ * Generate TypeScript config file content.
+ */
+function generateTypeScriptConfig(options) {
+    const { projectName, projectDescription, agents } = options;
+    return `import type { SquadConfig } from '@bradygaster/squad';
+
+/**
+ * Squad Configuration for ${projectName}
+ * ${projectDescription ? `\n * ${projectDescription}` : ''}
+ */
+const config: SquadConfig = {
+  version: '1.0.0',
+  
+  models: {
+    defaultModel: '${MODELS.DEFAULT}',
+    defaultTier: 'standard',
+    fallbackChains: {
+      premium: ${formatModelArray(MODELS.FALLBACK_CHAINS.premium)},
+      standard: ${formatModelArray(MODELS.FALLBACK_CHAINS.standard)},
+      fast: ${formatModelArray(MODELS.FALLBACK_CHAINS.fast)}
+    },
+    preferSameProvider: true,
+    respectTierCeiling: true,
+    nuclearFallback: {
+      enabled: false,
+      model: '${MODELS.NUCLEAR_FALLBACK}',
+      maxRetriesBeforeNuclear: ${MODELS.NUCLEAR_MAX_RETRIES}
+    }
+  },
+  
+  routing: {
+    rules: [
+      {
+        workType: 'feature-dev',
+        agents: ['@${agents[0]?.name || 'coordinator'}'],
+        confidence: 'high'
+      },
+      {
+        workType: 'bug-fix',
+        agents: ['@${agents.find(a => a.role === 'developer')?.name || agents[0]?.name || 'coordinator'}'],
+        confidence: 'high'
+      },
+      {
+        workType: 'testing',
+        agents: ['@${agents.find(a => a.role === 'tester')?.name || agents[0]?.name || 'coordinator'}'],
+        confidence: 'high'
+      },
+      {
+        workType: 'documentation',
+        agents: ['@${agents.find(a => a.role === 'scribe')?.name || agents[0]?.name || 'coordinator'}'],
+        confidence: 'high'
+      }
+    ],
+    governance: {
+      eagerByDefault: true,
+      scribeAutoRuns: false,
+      allowRecursiveSpawn: false
+    }
+  },
+  
+  casting: {
+    allowlistUniverses: [
+      'The Usual Suspects',
+      'Breaking Bad',
+      'The Wire',
+      'Firefly'
+    ],
+    overflowStrategy: 'generic',
+    universeCapacity: {}
+  },
+  
+  platforms: {
+    vscode: {
+      disableModelSelection: false,
+      scribeMode: 'sync'
+    }
+  }
+};
+
+export default config;
+`;
+}
+/**
+ * Generate JSON config file content.
+ */
+function generateJsonConfig(options) {
+    const { agents } = options;
+    const config = {
+        version: '1.0.0',
+        models: {
+            defaultModel: MODELS.DEFAULT,
+            defaultTier: 'standard',
+            fallbackChains: {
+                premium: [...MODELS.FALLBACK_CHAINS.premium],
+                standard: [...MODELS.FALLBACK_CHAINS.standard],
+                fast: [...MODELS.FALLBACK_CHAINS.fast]
+            },
+            preferSameProvider: true,
+            respectTierCeiling: true,
+            nuclearFallback: {
+                enabled: false,
+                model: MODELS.NUCLEAR_FALLBACK,
+                maxRetriesBeforeNuclear: MODELS.NUCLEAR_MAX_RETRIES
+            }
+        },
+        routing: {
+            rules: [
+                {
+                    workType: 'feature-dev',
+                    agents: [`@${agents[0]?.name || 'coordinator'}`],
+                    confidence: 'high'
+                },
+                {
+                    workType: 'bug-fix',
+                    agents: [`@${agents.find(a => a.role === 'developer')?.name || agents[0]?.name || 'coordinator'}`],
+                    confidence: 'high'
+                },
+                {
+                    workType: 'testing',
+                    agents: [`@${agents.find(a => a.role === 'tester')?.name || agents[0]?.name || 'coordinator'}`],
+                    confidence: 'high'
+                },
+                {
+                    workType: 'documentation',
+                    agents: [`@${agents.find(a => a.role === 'scribe')?.name || agents[0]?.name || 'coordinator'}`],
+                    confidence: 'high'
+                }
+            ],
+            governance: {
+                eagerByDefault: true,
+                scribeAutoRuns: false,
+                allowRecursiveSpawn: false
+            }
+        },
+        casting: {
+            allowlistUniverses: [
+                'The Usual Suspects',
+                'Breaking Bad',
+                'The Wire',
+                'Firefly'
+            ],
+            overflowStrategy: 'generic',
+            universeCapacity: {}
+        },
+        platforms: {
+            vscode: {
+                disableModelSelection: false,
+                scribeMode: 'sync'
+            }
+        }
+    };
+    return JSON.stringify(config, null, 2);
+}
+/**
+ * Generate SDK builder config file content (new defineSquad() format).
+ */
+function generateSDKBuilderConfig(options) {
+    const { projectName, projectDescription, agents } = options;
+    // Generate imports
+    let code = `import {\n  defineSquad,\n  defineTeam,\n  defineAgent,\n} from '@bradygaster/squad-sdk';\n\n`;
+    code += `/**\n * Squad Configuration — ${projectName}\n`;
+    if (projectDescription) {
+        code += ` *\n * ${projectDescription}\n`;
+    }
+    code += ` */\n`;
+    // Generate agent definitions
+    for (const agent of agents) {
+        const displayName = agent.displayName || titleCase(agent.name);
+        code += `const ${agent.name} = defineAgent({\n`;
+        code += `  name: '${agent.name}',\n`;
+        code += `  role: '${agent.role}',\n`;
+        code += `  description: '${displayName}',\n`;
+        code += `  status: 'active',\n`;
+        code += `});\n\n`;
+    }
+    // Generate squad config
+    code += `export default defineSquad({\n`;
+    code += `  version: '1.0.0',\n\n`;
+    code += `  team: defineTeam({\n`;
+    code += `    name: '${projectName}',\n`;
+    if (projectDescription) {
+        code += `    description: '${projectDescription.replace(/'/g, "\\'")}',\n`;
+    }
+    code += `    members: [${agents.map(a => `'${a.name}'`).join(', ')}],\n`;
+    code += `  }),\n\n`;
+    code += `  agents: [${agents.map(a => a.name).join(', ')}],\n`;
+    code += `});\n`;
+    return code;
+}
+// ============================================================================
+// Agent Template Generation
+// ============================================================================
+/**
+ * Generate charter.md content for an agent.
+ */
+function generateCharter(agent, projectName, projectDescription) {
+    const template = AGENT_TEMPLATES[agent.role];
+    const displayName = agent.displayName || template?.displayName || titleCase(agent.name);
+    const description = template?.description || 'Team member focused on their assigned responsibilities.';
+    return `# ${displayName} — ${titleCase(agent.role)}
+
+${description}
+
+## Project Context
+
+**Project:** ${projectName}
+${projectDescription ? `**Description:** ${projectDescription}\n` : ''}
+
+## Responsibilities
+
+- Collaborate with team members on assigned work
+- Maintain code quality and project standards
+- Document decisions and progress in history
+
+## Work Style
+
+- Read project context and team decisions before starting work
+- Communicate clearly with team members
+- Follow established patterns and conventions
+`;
+}
+/**
+ * Generate initial history.md content for an agent.
+ */
+function generateInitialHistory(agent, projectName, projectDescription, userName) {
+    const displayName = agent.displayName || AGENT_TEMPLATES[agent.role]?.displayName || titleCase(agent.name);
+    const now = new Date().toISOString().split('T')[0];
+    return `# Project Context
+
+${userName ? `- **Owner:** ${userName}\n` : ''}- **Project:** ${projectName}
+${projectDescription ? `- **Description:** ${projectDescription}\n` : ''}- **Created:** ${now}
+
+## Core Context
+
+Agent ${displayName} initialized and ready for work.
+
+## Recent Updates
+
+📌 Team initialized on ${now}
+
+## Learnings
+
+Initial setup complete.
+`;
+}
+/**
+ * Convert kebab-case or snake_case to Title Case.
+ */
+function titleCase(str) {
+    return str
+        .split(/[-_]/)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join(' ');
+}
+// ============================================================================
+// Initialization Functions
+// ============================================================================
+/**
+ * Stamp version into squad.agent.md content.
+ */
+function stampVersionInContent(content, version) {
+    return content.replace(/<!-- version: [^>]* -->/, `<!-- version: ${version} -->`);
+}
+/**
+ * Initialize a new Squad project.
+ *
+ * Creates:
+ * - .squad/ directory structure (agents, casting, decisions, skills, identity, etc.)
+ * - squad.config.ts or squad.config.json
+ * - Agent directories with charter.md and history.md
+ * - .gitattributes for merge drivers
+ * - .gitignore entries for logs
+ * - .github/agents/squad.agent.md
+ * - .github/workflows/ (optional)
+ * - .squad/templates/ (optional)
+ * - .copilot/mcp-config.json (optional)
+ * - Identity files (now.md, wisdom.md)
+ * - ceremonies.md
+ *
+ * @param options - Initialization options
+ * @returns Result with created file paths
+ */
+/**
+ * Workflow files that are part of the Squad framework and should always be installed.
+ * Other workflows in templates/workflows/ are generic CI/CD scaffolding and are opt-in.
+ */
+const FRAMEWORK_WORKFLOWS = [
+    'squad-heartbeat.yml',
+    'squad-issue-assign.yml',
+    'squad-triage.yml',
+    'sync-squad-labels.yml',
+];
+export async function initSquad(options) {
+    const { teamRoot, projectName, projectDescription, agents, configFormat = 'typescript', userName, skipExisting = true, includeWorkflows = true, includeTemplates = true, includeMcpConfig = true, projectType = 'unknown', version = '0.0.0', } = options;
+    const createdFiles = [];
+    const skippedFiles = [];
+    const agentDirs = [];
+    // Validate inputs
+    if (!teamRoot) {
+        throw new Error('teamRoot is required');
+    }
+    if (!projectName) {
+        throw new Error('projectName is required');
+    }
+    if (!agents || agents.length === 0) {
+        throw new Error('At least one agent is required');
+    }
+    // Get templates directory
+    const templatesDir = getSDKTemplatesDir();
+    // Helper to convert absolute path to relative
+    const toRelativePath = (absolutePath) => {
+        // Use path separator-agnostic approach
+        if (absolutePath.startsWith(teamRoot)) {
+            const relative = absolutePath.slice(teamRoot.length);
+            // Remove leading separator if present
+            return relative.startsWith('/') || relative.startsWith('\\')
+                ? relative.slice(1)
+                : relative;
+        }
+        return absolutePath;
+    };
+    // Helper to write file (respects skipExisting)
+    const writeIfNotExists = async (filePath, content) => {
+        if (existsSync(filePath) && skipExisting) {
+            skippedFiles.push(toRelativePath(filePath));
+            return false;
+        }
+        await mkdir(dirname(filePath), { recursive: true });
+        await writeFile(filePath, content, 'utf-8');
+        createdFiles.push(toRelativePath(filePath));
+        return true;
+    };
+    // Helper to copy file (respects skipExisting)
+    const copyIfNotExists = async (src, dest) => {
+        if (existsSync(dest) && skipExisting) {
+            skippedFiles.push(toRelativePath(dest));
+            return false;
+        }
+        await mkdir(dirname(dest), { recursive: true });
+        cpSync(src, dest);
+        createdFiles.push(toRelativePath(dest));
+        return true;
+    };
+    // -------------------------------------------------------------------------
+    // Create .squad/ directory structure
+    // -------------------------------------------------------------------------
+    const squadDir = join(teamRoot, '.squad');
+    const directories = [
+        join(squadDir, 'agents'),
+        join(squadDir, 'casting'),
+        join(squadDir, 'decisions'),
+        join(squadDir, 'decisions', 'inbox'),
+        join(squadDir, 'skills'),
+        join(squadDir, 'plugins'),
+        join(squadDir, 'identity'),
+        join(squadDir, 'orchestration-log'),
+        join(squadDir, 'log'),
+    ];
+    for (const dir of directories) {
+        if (!existsSync(dir)) {
+            await mkdir(dir, { recursive: true });
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Create .squad/config.json for squad settings
+    // -------------------------------------------------------------------------
+    const squadConfigPath = join(squadDir, 'config.json');
+    if (!existsSync(squadConfigPath)) {
+        const squadConfig = {
+            version: 1,
+            teamRoot: teamRoot,
+        };
+        // Only include extractionDisabled if explicitly set
+        if (options.extractionDisabled) {
+            squadConfig.extractionDisabled = true;
+        }
+        await writeFile(squadConfigPath, JSON.stringify(squadConfig, null, 2), 'utf-8');
+        createdFiles.push(toRelativePath(squadConfigPath));
+    }
+    // -------------------------------------------------------------------------
+    // Create configuration file
+    // -------------------------------------------------------------------------
+    // When configFormat is 'markdown', skip config file generation entirely
+    let configPath;
+    if (configFormat !== 'markdown') {
+        const configFileName = configFormat === 'sdk' ? 'squad.config.ts' :
+            configFormat === 'typescript' ? 'squad.config.ts' : 'squad.config.json';
+        configPath = join(teamRoot, configFileName);
+        const configContent = configFormat === 'sdk' ? generateSDKBuilderConfig(options) :
+            configFormat === 'typescript' ? generateTypeScriptConfig(options) :
+                generateJsonConfig(options);
+        await writeIfNotExists(configPath, configContent);
+    }
+    else {
+        // No config file for markdown-only mode
+        configPath = '';
+    }
+    // -------------------------------------------------------------------------
+    // Create agent directories and files
+    // -------------------------------------------------------------------------
+    const agentsDir = join(squadDir, 'agents');
+    for (const agent of agents) {
+        const agentDir = join(agentsDir, agent.name);
+        await mkdir(agentDir, { recursive: true });
+        agentDirs.push(agentDir);
+        // Create charter.md
+        const charterPath = join(agentDir, 'charter.md');
+        const charterContent = generateCharter(agent, projectName, projectDescription);
+        await writeIfNotExists(charterPath, charterContent);
+        // Create history.md
+        const historyPath = join(agentDir, 'history.md');
+        const historyContent = generateInitialHistory(agent, projectName, projectDescription, userName);
+        await writeIfNotExists(historyPath, historyContent);
+    }
+    // -------------------------------------------------------------------------
+    // Create identity files (now.md, wisdom.md)
+    // -------------------------------------------------------------------------
+    const identityDir = join(squadDir, 'identity');
+    const nowMdPath = join(identityDir, 'now.md');
+    const wisdomMdPath = join(identityDir, 'wisdom.md');
+    const nowContent = `---
+updated_at: ${new Date().toISOString()}
+focus_area: Initial setup
+active_issues: []
+---
+
+# What We're Focused On
+
+Getting started. Updated by coordinator at session start.
+`;
+    const wisdomContent = `---
+last_updated: ${new Date().toISOString()}
+---
+
+# Team Wisdom
+
+Reusable patterns and heuristics learned through work. NOT transcripts — each entry is a distilled, actionable insight.
+
+## Patterns
+
+<!-- Append entries below. Format: **Pattern:** description. **Context:** when it applies. -->
+`;
+    await writeIfNotExists(nowMdPath, nowContent);
+    await writeIfNotExists(wisdomMdPath, wisdomContent);
+    // -------------------------------------------------------------------------
+    // Create ceremonies.md
+    // -------------------------------------------------------------------------
+    const ceremoniesDest = join(squadDir, 'ceremonies.md');
+    if (templatesDir && existsSync(join(templatesDir, 'ceremonies.md'))) {
+        await copyIfNotExists(join(templatesDir, 'ceremonies.md'), ceremoniesDest);
+    }
+    // -------------------------------------------------------------------------
+    // Create decisions.md (canonical location at squad root)
+    // -------------------------------------------------------------------------
+    const decisionsPath = join(squadDir, 'decisions.md');
+    const decisionsContent = `# Squad Decisions
+
+## Active Decisions
+
+No decisions recorded yet.
+
+## Governance
+
+- All meaningful changes require team consensus
+- Document architectural decisions here
+- Keep history focused on work, decisions focused on direction
+`;
+    await writeIfNotExists(decisionsPath, decisionsContent);
+    // -------------------------------------------------------------------------
+    // Create team.md (required by shell lifecycle)
+    // -------------------------------------------------------------------------
+    const teamPath = join(squadDir, 'team.md');
+    const teamContent = `# Squad Team
+
+> ${projectDescription || projectName}
+
+## Coordinator
+
+| Name | Role | Notes |
+|------|------|-------|
+| Squad | Coordinator | Routes work, enforces handoffs and reviewer gates. |
+
+## Members
+
+| Name | Role | Charter | Status |
+|------|------|---------|--------|
+
+## Project Context
+
+- **Project:** ${projectName}
+${projectDescription ? `- **Description:** ${projectDescription}\n` : ''}- **Created:** ${new Date().toISOString().split('T')[0]}
+`;
+    await writeIfNotExists(teamPath, teamContent);
+    // -------------------------------------------------------------------------
+    // Create routing.md
+    // -------------------------------------------------------------------------
+    const routingPath = join(squadDir, 'routing.md');
+    if (templatesDir && existsSync(join(templatesDir, 'routing.md'))) {
+        await copyIfNotExists(join(templatesDir, 'routing.md'), routingPath);
+    }
+    else {
+        const routingContent = `# Squad Routing
+
+## Work Type Rules
+
+| Work Type | Primary Agent | Fallback |
+|-----------|---------------|----------|
+
+## Governance
+
+- Route based on work type and agent expertise
+- Update this file as team capabilities evolve
+`;
+        await writeIfNotExists(routingPath, routingContent);
+    }
+    // -------------------------------------------------------------------------
+    // Copy starter skills
+    // -------------------------------------------------------------------------
+    const skillsDir = join(squadDir, 'skills');
+    if (templatesDir && existsSync(join(templatesDir, 'skills'))) {
+        const skillsSrc = join(templatesDir, 'skills');
+        const existingSkills = existsSync(skillsDir) ? readdirSync(skillsDir) : [];
+        if (existingSkills.length === 0) {
+            cpSync(skillsSrc, skillsDir, { recursive: true });
+            createdFiles.push('.squad/skills');
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Create .gitattributes for merge drivers
+    // -------------------------------------------------------------------------
+    const gitattributesPath = join(teamRoot, '.gitattributes');
+    const unionRules = [
+        '.squad/decisions.md merge=union',
+        '.squad/agents/*/history.md merge=union',
+        '.squad/log/** merge=union',
+        '.squad/orchestration-log/** merge=union',
+    ];
+    let existingAttrs = '';
+    if (existsSync(gitattributesPath)) {
+        existingAttrs = readFileSync(gitattributesPath, 'utf-8');
+    }
+    const missingRules = unionRules.filter(rule => !existingAttrs.includes(rule));
+    if (missingRules.length > 0) {
+        const block = (existingAttrs && !existingAttrs.endsWith('\n') ? '\n' : '')
+            + '# Squad: union merge for append-only team state files\n'
+            + missingRules.join('\n') + '\n';
+        await appendFile(gitattributesPath, block);
+        createdFiles.push(toRelativePath(gitattributesPath));
+    }
+    // -------------------------------------------------------------------------
+    // Create .gitignore entries for runtime state (logs, inbox, sessions)
+    // These paths are written during normal squad operation but should not be
+    // committed to version control (they are runtime state).
+    // -------------------------------------------------------------------------
+    const gitignorePath = join(teamRoot, '.gitignore');
+    const ignoreEntries = [
+        '.squad/orchestration-log/',
+        '.squad/log/',
+        '.squad/decisions/inbox/',
+        '.squad/sessions/',
+    ];
+    let existingIgnore = '';
+    if (existsSync(gitignorePath)) {
+        existingIgnore = readFileSync(gitignorePath, 'utf-8');
+    }
+    const missingIgnore = ignoreEntries.filter(entry => !existingIgnore.includes(entry));
+    if (missingIgnore.length > 0) {
+        const block = (existingIgnore && !existingIgnore.endsWith('\n') ? '\n' : '')
+            + '# Squad: ignore runtime state (logs, inbox, sessions)\n'
+            + missingIgnore.join('\n') + '\n';
+        await appendFile(gitignorePath, block);
+        createdFiles.push(toRelativePath(gitignorePath));
+    }
+    // -------------------------------------------------------------------------
+    // Create .github/agents/squad.agent.md
+    // -------------------------------------------------------------------------
+    const agentFile = join(teamRoot, '.github', 'agents', 'squad.agent.md');
+    if (!existsSync(agentFile) || !skipExisting) {
+        if (templatesDir && existsSync(join(templatesDir, 'squad.agent.md'))) {
+            let agentContent = readFileSync(join(templatesDir, 'squad.agent.md'), 'utf-8');
+            agentContent = stampVersionInContent(agentContent, version);
+            await mkdir(dirname(agentFile), { recursive: true });
+            await writeFile(agentFile, agentContent, 'utf-8');
+            createdFiles.push(toRelativePath(agentFile));
+        }
+    }
+    else {
+        skippedFiles.push(toRelativePath(agentFile));
+    }
+    // -------------------------------------------------------------------------
+    // Copy .squad/templates/ (optional)
+    // -------------------------------------------------------------------------
+    if (includeTemplates && templatesDir) {
+        const templatesDest = join(teamRoot, '.squad', 'templates');
+        if (!existsSync(templatesDest)) {
+            cpSync(templatesDir, templatesDest, { recursive: true });
+            createdFiles.push(toRelativePath(templatesDest));
+        }
+        else {
+            skippedFiles.push(toRelativePath(templatesDest));
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Copy workflows (optional)
+    // -------------------------------------------------------------------------
+    if (includeWorkflows && templatesDir && existsSync(join(templatesDir, 'workflows'))) {
+        const workflowsSrc = join(templatesDir, 'workflows');
+        const workflowsDest = join(teamRoot, '.github', 'workflows');
+        if (statSync(workflowsSrc).isDirectory()) {
+            const allWorkflowFiles = readdirSync(workflowsSrc).filter(f => f.endsWith('.yml'));
+            const workflowFiles = allWorkflowFiles.filter(f => FRAMEWORK_WORKFLOWS.includes(f));
+            await mkdir(workflowsDest, { recursive: true });
+            for (const file of workflowFiles) {
+                const destFile = join(workflowsDest, file);
+                if (!existsSync(destFile) || !skipExisting) {
+                    cpSync(join(workflowsSrc, file), destFile);
+                    createdFiles.push(toRelativePath(destFile));
+                }
+                else {
+                    skippedFiles.push(toRelativePath(destFile));
+                }
+            }
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Create sample MCP config (optional)
+    // -------------------------------------------------------------------------
+    if (includeMcpConfig) {
+        const mcpConfigPath = join(teamRoot, '.copilot', 'mcp-config.json');
+        if (!existsSync(mcpConfigPath)) {
+            const mcpSample = {
+                mcpServers: {
+                    "EXAMPLE-trello": {
+                        command: "npx",
+                        args: ["-y", "@trello/mcp-server"],
+                        env: {
+                            TRELLO_API_KEY: "${TRELLO_API_KEY}",
+                            TRELLO_TOKEN: "${TRELLO_TOKEN}"
+                        }
+                    }
+                }
+            };
+            await mkdir(dirname(mcpConfigPath), { recursive: true });
+            await writeFile(mcpConfigPath, JSON.stringify(mcpSample, null, 2) + '\n', 'utf-8');
+            createdFiles.push(toRelativePath(mcpConfigPath));
+        }
+        else {
+            skippedFiles.push(toRelativePath(mcpConfigPath));
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Generate .squad/workstreams.json (when streams provided)
+    // -------------------------------------------------------------------------
+    if (options.streams && options.streams.length > 0) {
+        const workstreamsConfig = {
+            workstreams: options.streams,
+            defaultWorkflow: 'branch-per-issue',
+        };
+        const workstreamsPath = join(squadDir, 'workstreams.json');
+        await writeIfNotExists(workstreamsPath, JSON.stringify(workstreamsConfig, null, 2) + '\n');
+    }
+    // -------------------------------------------------------------------------
+    // Add .squad-workstream to .gitignore
+    // -------------------------------------------------------------------------
+    {
+        const workstreamIgnoreEntry = '.squad-workstream';
+        let currentIgnore = '';
+        if (existsSync(gitignorePath)) {
+            currentIgnore = readFileSync(gitignorePath, 'utf-8');
+        }
+        if (!currentIgnore.includes(workstreamIgnoreEntry)) {
+            const block = (currentIgnore && !currentIgnore.endsWith('\n') ? '\n' : '')
+                + '# Squad: workstream activation file (local to this machine)\n'
+                + workstreamIgnoreEntry + '\n';
+            await appendFile(gitignorePath, block);
+            createdFiles.push(toRelativePath(gitignorePath));
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Create .first-run marker
+    // -------------------------------------------------------------------------
+    const firstRunMarker = join(squadDir, '.first-run');
+    if (!existsSync(firstRunMarker)) {
+        await writeFile(firstRunMarker, new Date().toISOString() + '\n', 'utf-8');
+        createdFiles.push(toRelativePath(firstRunMarker));
+    }
+    // -------------------------------------------------------------------------
+    // Store init prompt for REPL auto-casting
+    // -------------------------------------------------------------------------
+    if (options.prompt) {
+        const promptFile = join(squadDir, '.init-prompt');
+        await writeFile(promptFile, options.prompt, 'utf-8');
+        createdFiles.push(toRelativePath(promptFile));
+    }
+    return {
+        createdFiles,
+        skippedFiles,
+        configPath,
+        agentDirs,
+        agentFile,
+        squadDir,
+    };
+}
+/**
+ * Clean up orphan .init-prompt file.
+ * Called by CLI on Ctrl+C abort to remove partial state.
+ *
+ * @param squadDir - Path to the .squad directory
+ */
+export async function cleanupOrphanInitPrompt(squadDir) {
+    const promptFile = join(squadDir, '.init-prompt');
+    if (existsSync(promptFile)) {
+        await unlink(promptFile);
+    }
+}
+//# sourceMappingURL=init.js.map