@mark-gozner/aigile-method 0.4.5

package/tools/installer/README.md

@@ -0,0 +1,24 @@
+# AIgile Installer (GitHub Copilot Only)
+
+Usage:
+
+- Interactive (via your existing CLI):
+  - `npx aigile-method install`
+  - `npm run install:aigile`
+  - Add MCP templates: `npx aigile-method install --with-mcp`
+  - Add mock VS Code MCP settings: `npx aigile-method install --with-mcp-settings`
+  - Interactive prompts will ask about MCP options; use `--yes` to accept defaults quickly
+
+What it does:
+- Copies `core/` into `.aigile-core/` in your current project
+- Generates GitHub Copilot chat modes from your agents into `.github/chatmodes/*.chatmode.md`
+- Leaves your repo otherwise untouched
+ - Prints a friendly ASCII banner during installation
+ - Optional: generates `.vscode/mcp.json` with template servers and input prompts
+ - Optional: updates `.vscode/settings.json` with mock MCP endpoints (for demos)
+ - Shows a small “Created by GM” banner and a short summary on completion
+
+Notes:
+- This installer is intentionally scoped to GitHub Copilot compatibility.
+- MCP/other IDEs can be added later as separate options.
+ - After generating `.vscode/mcp.json`, open VS Code and fill in the prompted API keys.

package/tools/installer/lib/ide-setup.js

@@ -0,0 +1,295 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+
+/**
+ * Full tool list for all agents (except orchestrator)
+ */
+const FULL_AGENT_TOOLS = [
+  // VS Code tools
+  'vscode/getProjectSetupInfo', 'vscode/installExtension', 'vscode/newWorkspace', 
+  'vscode/openSimpleBrowser', 'vscode/runCommand', 'vscode/vscodeAPI', 'vscode/extensions',
+  // Execute tools
+  'execute/runNotebookCell', 'execute/testFailure', 'execute/getTerminalOutput',
+  'execute/runTask', 'execute/createAndRunTask', 'execute/runInTerminal', 'execute/runTests',
+  // Read tools
+  'read/getNotebookSummary', 'read/problems', 'read/readFile', 'read/readNotebookCellOutput',
+  'read/terminalSelection', 'read/terminalLastCommand', 'read/getTaskOutput',
+  // Agent tools
+  'agent/runSubagent',
+  // Edit tools
+  'edit/createDirectory', 'edit/createFile', 'edit/createJupyterNotebook', 
+  'edit/editFiles', 'edit/editNotebook',
+  // Search tools
+  'search/changes', 'search/codebase', 'search/fileSearch', 'search/listDirectory',
+  'search/searchResults', 'search/textSearch', 'search/usages', 'search/searchSubagent',
+  // Web tools
+  'web/fetch', 'web/githubRepo',
+  // Context7 MCP
+  'upstash/context7/query-docs', 'upstash/context7/resolve-library-id',
+  // GitHub MCP
+  'github/add_comment_to_pending_review', 'github/add_issue_comment', 'github/assign_copilot_to_issue',
+  'github/create_branch', 'github/create_or_update_file', 'github/create_pull_request',
+  'github/create_repository', 'github/delete_file', 'github/fork_repository', 'github/get_commit',
+  'github/get_file_contents', 'github/get_label', 'github/get_latest_release', 'github/get_me',
+  'github/get_release_by_tag', 'github/get_tag', 'github/get_team_members', 'github/get_teams',
+  'github/issue_read', 'github/issue_write', 'github/list_branches', 'github/list_commits',
+  'github/list_issue_types', 'github/list_issues', 'github/list_pull_requests', 'github/list_releases',
+  'github/list_tags', 'github/merge_pull_request', 'github/pull_request_read', 
+  'github/pull_request_review_write', 'github/push_files', 'github/request_copilot_review',
+  'github/search_code', 'github/search_issues', 'github/search_pull_requests',
+  'github/search_repositories', 'github/search_users', 'github/sub_issue_write',
+  'github/update_pull_request', 'github/update_pull_request_branch',
+  // Other tools
+  'askQuestions', 'todo',
+  // GitHub PR extension tools
+  'github.vscode-pull-request-github/issue_fetch', 'github.vscode-pull-request-github/suggest-fix',
+  'github.vscode-pull-request-github/searchSyntax', 'github.vscode-pull-request-github/doSearch',
+  'github.vscode-pull-request-github/renderIssues', 'github.vscode-pull-request-github/activePullRequest',
+  'github.vscode-pull-request-github/openPullRequest'
+];
+
+/**
+ * Agent metadata extracted from legacy YAML blocks
+ */
+const AGENT_METADATA = {
+  'aigile-orchestrator': {
+    description: 'PURE COORDINATOR - I have NO implementation tools. I can ONLY delegate via runSubagent.',
+    tools: ['agent/runSubagent'],
+    model: 'Claude Opus 4.5',
+    handoffs: [
+      { label: '🏗️ Architecture Review', agent: 'architect', prompt: 'Analyze the architecture and provide recommendations.', send: false },
+      { label: '💻 Start Implementation', agent: 'dev', prompt: 'Implement the plan using test-driven development.', send: false },
+      { label: '🧪 Run QA Gate', agent: 'qa', prompt: 'Review and test the implementation for quality.', send: false },
+      { label: '📋 Refine Backlog', agent: 'po', prompt: 'Refine the backlog items based on discussion.', send: false },
+      { label: '🧠 Analyze Requirements', agent: 'analyst', prompt: 'Analyze requirements and provide breakdown.', send: false },
+    ],
+    infer: false
+  },
+  'dev': {
+    description: 'Full Stack Developer - code implementation, debugging, refactoring, and test-driven development.',
+    tools: FULL_AGENT_TOOLS,
+    model: 'Claude Opus 4.5',
+    handoffs: [
+      { label: '🧪 Request QA Review', agent: 'qa', prompt: 'Review the implementation above for quality.', send: false },
+      { label: '🏗️ Architecture Check', agent: 'architect', prompt: 'Verify architecture compliance.', send: false },
+    ],
+    infer: true
+  },
+  'architect': {
+    description: 'Software Architect - architecture analysis, code review, documentation, and system design.',
+    tools: FULL_AGENT_TOOLS,
+    model: 'Claude Opus 4.5',
+    handoffs: [
+      { label: '💻 Start Implementation', agent: 'dev', prompt: 'Implement the architecture recommendations.', send: false },
+      { label: '📋 Create Stories', agent: 'po', prompt: 'Create backlog items for architecture changes.', send: false },
+    ],
+    infer: true
+  },
+  'po': {
+    description: 'Product Owner - story creation, backlog management, and Jira integration.',
+    tools: FULL_AGENT_TOOLS,
+    model: 'Claude Opus 4.5',
+    handoffs: [
+      { label: '💻 Implement Story', agent: 'dev', prompt: 'Implement the story defined above.', send: false },
+      { label: '🧠 Analyze Further', agent: 'analyst', prompt: 'Provide deeper analysis of requirements.', send: false },
+    ],
+    infer: true
+  },
+  'qa': {
+    description: 'QA Engineer - testing, quality gates, E2E verification, and test automation.',
+    tools: FULL_AGENT_TOOLS,
+    model: 'Claude Opus 4.5',
+    handoffs: [
+      { label: '💻 Fix Issues', agent: 'dev', prompt: 'Fix the issues identified in QA review.', send: false },
+      { label: '📋 Update Stories', agent: 'po', prompt: 'Update stories based on QA findings.', send: false },
+    ],
+    infer: true
+  },
+  'analyst': {
+    description: 'Business Analyst - requirements analysis, brainstorming, research, and elicitation.',
+    tools: FULL_AGENT_TOOLS,
+    model: 'Claude Opus 4.5',
+    handoffs: [
+      { label: '📋 Create Stories', agent: 'po', prompt: 'Create stories from analysis findings.', send: false },
+      { label: '🏗️ Architecture Review', agent: 'architect', prompt: 'Review architecture implications.', send: false },
+    ],
+    infer: true
+  },
+  'pm': {
+    description: 'Project Manager - project planning, backlog sync, PRDs, and roadmap management.',
+    tools: FULL_AGENT_TOOLS,
+    model: 'Claude Opus 4.5',
+    handoffs: [
+      { label: '📋 Refine Stories', agent: 'po', prompt: 'Refine the stories in the plan.', send: false },
+    ],
+    infer: true
+  },
+  'sm': {
+    description: 'Scrum Master - sprint ceremonies, standup facilitation, and team coordination.',
+    tools: FULL_AGENT_TOOLS,
+    model: 'Claude Opus 4.5',
+    handoffs: [],
+    infer: true
+  },
+  'ui-expert': {
+    description: 'UI Expert - design system audit, Figma integration, and component specifications.',
+    tools: FULL_AGENT_TOOLS,
+    model: 'Claude Opus 4.5',
+    handoffs: [
+      { label: '💻 Implement UI', agent: 'dev', prompt: 'Implement the UI specifications.', send: false },
+    ],
+    infer: true
+  },
+  'ux-expert': {
+    description: 'UX Expert - user experience design, frontend specs, and user journey mapping.',
+    tools: FULL_AGENT_TOOLS,
+    model: 'Claude Opus 4.5',
+    handoffs: [
+      { label: '🖌️ Design System', agent: 'ui-expert', prompt: 'Create design system components.', send: false },
+      { label: '💻 Implement UX', agent: 'dev', prompt: 'Implement the UX recommendations.', send: false },
+    ],
+    infer: true
+  },
+};
+
+/**
+ * Extract agent ID from filename
+ */
+function getAgentId(filename) {
+  return filename
+    .replace(/\.agent\.md$/, '')
+    .replace(/\.md$/, '');
+}
+
+/**
+ * Check if file is already in new agent format
+ */
+function isNewAgentFormat(filename) {
+  return filename.endsWith('.agent.md');
+}
+
+/**
+ * Generate YAML frontmatter for custom agent
+ */
+function generateFrontmatter(id, metadata) {
+  const lines = ['---'];
+  
+  if (metadata.name) lines.push(`name: ${metadata.name}`);
+  lines.push(`description: "${metadata.description || `Activates the ${id} agent persona (AIgile).`}"`);
+  if (metadata.argumentHint) lines.push(`argument-hint: "${metadata.argumentHint}"`);
+  
+  if (metadata.tools && metadata.tools.length > 0) {
+    lines.push('tools:');
+    for (const tool of metadata.tools) {
+      lines.push(`  - ${tool}`);
+    }
+  }
+  
+  // Always add model - default to Claude Opus 4.5
+  lines.push(`model: ${metadata.model || 'Claude Opus 4.5'}`);
+  if (metadata.infer !== undefined) lines.push(`infer: ${metadata.infer}`);
+  
+  if (metadata.handoffs && metadata.handoffs.length > 0) {
+    lines.push('handoffs:');
+    for (const handoff of metadata.handoffs) {
+      lines.push(`  - label: "${handoff.label}"`);
+      lines.push(`    agent: ${handoff.agent}`);
+      lines.push(`    prompt: "${handoff.prompt}"`);
+      lines.push(`    send: ${handoff.send}`);
+    }
+  }
+  
+  lines.push('---');
+  return lines.join('\n');
+}
+
+/**
+ * Setup GitHub Copilot custom agents (new format)
+ * Creates .agent.md files in .github/agents/ folder
+ * 
+ * @deprecated destChatmodesDir parameter - now creates agents in .github/agents/
+ */
+export function setupGithubCopilot({ srcAgentsDir, destChatmodesDir, destAgentsDir }){
+  // Use new agents directory, fallback to chatmodes for backward compatibility
+  const targetDir = destAgentsDir || destChatmodesDir?.replace('chatmodes', 'agents') || destChatmodesDir;
+  
+  fs.mkdirpSync(targetDir);
+  if(!srcAgentsDir || !fs.existsSync(srcAgentsDir)) return;
+
+  const processedAgents = [];
+
+  for(const name of fs.readdirSync(srcAgentsDir)){
+    if(!name.endsWith('.md')) continue;
+    
+    const id = getAgentId(name);
+    const srcPath = path.join(srcAgentsDir, name);
+    const agentMd = fs.readFileSync(srcPath, 'utf8');
+    
+    // If already in new .agent.md format, copy directly
+    if (isNewAgentFormat(name)) {
+      fs.copyFileSync(srcPath, path.join(targetDir, name));
+      processedAgents.push({ id, format: 'native' });
+      continue;
+    }
+
+    // Convert legacy format to new custom agent format
+    const metadata = AGENT_METADATA[id] || {
+      description: `Activates the ${id} agent persona (AIgile).`,
+      tools: ['search', 'fetch', 'codebase', 'problems'],
+      handoffs: [],
+      infer: true
+    };
+    
+    const frontmatter = generateFrontmatter(id, metadata);
+    
+    // Transform the content - remove old activation notice if present
+    let content = agentMd;
+    
+    // Add activation context header
+    const header = [
+      '',
+      '# Activation Notice',
+      '',
+      'This agent is part of the AIgile framework. The instructions below define your operating guidelines.',
+      'Use `#tool:runSubagent` to delegate specialized tasks to other agents when appropriate.',
+      '',
+    ].join('\n');
+
+    const out = `${frontmatter}${header}${content}`;
+    const destFile = path.join(targetDir, `${id}.agent.md`);
+    fs.writeFileSync(destFile, out, 'utf8');
+    processedAgents.push({ id, format: 'converted' });
+  }
+
+  return processedAgents;
+}
+
+/**
+ * Setup legacy chatmodes (deprecated - for backward compatibility)
+ * @deprecated Use setupGithubCopilot with destAgentsDir instead
+ */
+export function setupLegacyChatmodes({ srcAgentsDir, destChatmodesDir }){
+  console.warn('Warning: chatmodes are deprecated. Use custom agents (.github/agents/) instead.');
+  fs.mkdirpSync(destChatmodesDir);
+  if(!srcAgentsDir || !fs.existsSync(srcAgentsDir)) return;
+
+  for(const name of fs.readdirSync(srcAgentsDir)){
+    if(!name.endsWith('.md')) continue;
+    const id = getAgentId(name);
+    const agentMd = fs.readFileSync(path.join(srcAgentsDir, name), 'utf8');
+
+    const header = [
+      '---',
+      `description: "Activates the ${id} agent persona (AIgile)."`,
+      '---',
+      '',
+      '# Activation Notice',
+      'This file contains the full agent operating guidelines for GitHub Copilot Chat.',
+      'Follow the YAML inside to assume this role and operate within these constraints.',
+      '',
+    ].join('\n');
+
+    const out = `${header}${agentMd}`;
+    fs.writeFileSync(path.join(destChatmodesDir, `${id}.chatmode.md`), out, 'utf8');
+  }
+}

package/tools/installer/lib/installer.js

@@ -0,0 +1,131 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { fileURLToPath } from 'node:url';
+import { setupGithubCopilot, setupLegacyChatmodes } from './ide-setup.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, '..', '..');
+
+function copyDir(src, dest){
+  if(!fs.existsSync(src)) return;
+  fs.mkdirpSync(dest);
+  for(const entry of fs.readdirSync(src, {withFileTypes:true})){
+    const sp = path.join(src, entry.name);
+    const dp = path.join(dest, entry.name);
+    if(entry.isDirectory()) copyDir(sp, dp);
+    else fs.copyFileSync(sp, dp);
+  }
+}
+
+// legacy helper kept for compatibility; now defers to setupGithubCopilot
+function makeChatModesFromAgents(srcAgentsDir, destChatmodesDir){
+  setupGithubCopilot({ srcAgentsDir, destChatmodesDir });
+}
+
+export async function runInstall({ withMcp=false, includeJavaInstructions=false, useLegacyChatmodes=false } = {}){
+  const cwd = process.cwd();
+
+  // 1) Copy core -> .aigile-core
+  const coreSrc = path.join(projectRoot, 'core');
+  const coreDest = path.join(cwd, '.aigile-core');
+  copyDir(coreSrc, coreDest);
+
+  // 2) Generate GitHub Copilot custom agents (new format: .github/agents/*.agent.md)
+  //    Or legacy chatmodes if explicitly requested
+  const srcAgentsDir = path.join(coreSrc, 'agents');
+  let outputDir;
+  
+  if (useLegacyChatmodes) {
+    // Deprecated: Use legacy chatmodes format
+    outputDir = path.join(cwd, '.github', 'chatmodes');
+    setupLegacyChatmodes({ srcAgentsDir, destChatmodesDir: outputDir });
+    console.log('⚠️  Warning: Using legacy chatmodes format. Consider upgrading to custom agents.');
+  } else {
+    // New format: Custom agents with handoffs and runSubagent support
+    outputDir = path.join(cwd, '.github', 'agents');
+    const agents = setupGithubCopilot({ srcAgentsDir, destAgentsDir: outputDir });
+    console.log(`✅ Created ${agents?.length || 0} custom agents in .github/agents/`);
+  }
+
+  // 3) Create copilot-instructions.md for workspace-wide settings
+  const instructionsDir = path.join(cwd, '.github');
+  fs.mkdirpSync(instructionsDir);
+  const copilotInstructionsPath = path.join(instructionsDir, 'copilot-instructions.md');
+  if (!fs.existsSync(copilotInstructionsPath)) {
+    const copilotInstructions = `# AIgile Copilot Instructions
+
+This project uses the AIgile framework for AI-assisted development.
+
+## Custom Agents
+
+Custom agents are available in \`.github/agents/\`. Use them by selecting from the agent dropdown in Copilot Chat.
+
+### Available Agents
+- **aigile-orchestrator**: Master orchestrator - coordinates workflows and delegates to specialists
+- **dev**: Full Stack Developer - implementation, debugging, TDD
+- **architect**: Software Architect - architecture review, documentation
+- **po**: Product Owner - story creation, backlog management
+- **qa**: QA Engineer - testing, quality gates
+- **analyst**: Business Analyst - requirements analysis
+- **pm**: Project Manager - project planning
+- **sm**: Scrum Master - ceremonies, team coordination
+- **ui-expert**: UI Expert - design systems, Figma
+- **ux-expert**: UX Expert - user experience design
+
+## Subagent Delegation
+
+The orchestrator and specialist agents can delegate tasks using \`#tool:runSubagent\`.
+This enables autonomous multi-step workflows where complex tasks are broken down
+and routed to the appropriate specialist.
+
+## Handoffs
+
+Agents support handoffs - use the handoff buttons after a response to transition
+to another specialist with context preserved.
+
+## Project Configuration
+
+See \`.aigile-core/core-config.yaml\` for project-specific settings.
+`;
+    fs.writeFileSync(copilotInstructionsPath, copilotInstructions, 'utf8');
+  }
+
+  // 4) Optional MCP scaffolding into .vscode (disabled by default for Copilot-only)
+  if(withMcp){
+    const vsSettingsDir = path.join(cwd, '.vscode');
+    fs.mkdirpSync(vsSettingsDir);
+    const settingsPath = path.join(vsSettingsDir, 'settings.json');
+    if(!fs.existsSync(settingsPath)){
+      fs.writeFileSync(settingsPath, JSON.stringify({ 
+        "aigile.mcp": { enabled: true },
+        "github.copilot.chat.customAgents.showOrganizationAndEnterpriseAgents": true
+      }, null, 2));
+    }
+  }
+
+  if(includeJavaInstructions){
+    const javaInstructionsSrc = path.join(projectRoot, 'core', 'instructions', 'java.instructions.md');
+    if(fs.existsSync(javaInstructionsSrc)){
+      const instructionsDest = path.join(cwd, '.github', 'instructions');
+      fs.mkdirpSync(instructionsDest);
+      fs.copyFileSync(javaInstructionsSrc, path.join(instructionsDest, 'java.instructions.md'));
+    }
+  }
+
+  // Marker file with version info
+  const markerContent = JSON.stringify({
+    version: '0.3.0',
+    format: useLegacyChatmodes ? 'chatmodes' : 'agents',
+    installedAt: new Date().toISOString(),
+    features: {
+      customAgents: !useLegacyChatmodes,
+      handoffs: !useLegacyChatmodes,
+      runSubagent: !useLegacyChatmodes,
+      mcp: withMcp
+    }
+  }, null, 2);
+  fs.writeFileSync(path.join(cwd, '.aigile'), markerContent, 'utf8');
+
+  return { coreDest, agentsDir: outputDir, chatmodesDir: useLegacyChatmodes ? outputDir : null };
+}

package/tools/md-assets/web-agent-startup-instructions.md

@@ -0,0 +1,21 @@
+# Web Agent Bundle Instructions
+
+This header is included at the top of each generated AIgile bundle (team and per-agent) to provide context for downstream tooling and validation.
+
+Purpose:
+- Identify the file as a structured AIgile bundle
+- Provide quick usage guidance
+- Ensure automated validators can assert presence (looks for the phrase: Web Agent Bundle Instructions)
+
+Usage Guidance:
+1. Each subsequent section is wrapped with START/END markers of the form:
+   ==================== START: .aigile-core/<relative-path> ====================
+   (content)
+   ==================== END: .aigile-core/<relative-path> ====================
+2. Tools parsing this file should iterate over marker pairs to reconstruct original source files under `.aigile-core/`.
+3. Do not edit marker lines manually—regenerate bundles instead (`npm run build`).
+4. Additional metadata or future headers can be appended below this notice.
+
+Notes:
+- Missing this header triggers validation failure.
+- Keep this concise; large instructions inflate bundle size.

package/tools/postinstall.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+/**
+ * Postinstall bootstrap for @mark-gozner/aigile-method
+ *
+ * Goal: Allow a single command install:
+ *   npm install @mark-gozner/aigile-method
+ * which automatically lays down .aigile-core and agents in the *consuming* project.
+ *
+ * Safeguards / Opt-outs:
+ *   - Set AIGILE_NO_POSTINSTALL=1 to skip entirely
+ *   - Set CI=true (common in pipelines) to skip (avoid polluting build images)
+ *   - Set AIGILE_INSTALL_ARGS="--with-mcp" to pass extra flags
+ *   - Set AIGILE_SILENT=1 to suppress non-error logging
+ *
+ * Behavior:
+ *   1. Detect if running inside the package itself (development) -> if so, skip
+ *   2. Otherwise invoke tools/cli.js install with optional flags
+ */
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const pkgRoot = path.resolve(__dirname, '..');
+
+function log(msg){ if(!process.env.AIGILE_SILENT) console.log(`[aigile-postinstall] ${msg}`); }
+function warn(msg){ console.warn(`[aigile-postinstall] WARN: ${msg}`); }
+function skip(reason){ log(`Skipped automatic install: ${reason}`); process.exit(0); }
+
+// 1. Global skips
+if(process.env.AIGILE_NO_POSTINSTALL === '1') skip('AIGILE_NO_POSTINSTALL=1');
+if(process.env.CI === 'true') skip('CI=true');
+
+// 2. Detect if we're inside the package's own repo (development scenario)
+// Heuristic: presence of .git AND core/agents folder at same root as this script.
+const devIndicators = [
+  path.join(pkgRoot, '.git'),
+  path.join(pkgRoot, 'core', 'agents')
+];
+const looksLikeDev = devIndicators.every(p => fs.existsSync(p));
+if(looksLikeDev) skip('development workspace detected');
+
+// 3. Determine project root (one level above node_modules/<this package>)
+// process.cwd() during postinstall is the consuming project root for npm (unless workspaces alter it)
+const projectRoot = process.cwd();
+if(projectRoot.startsWith(pkgRoot)) {
+  // Unusual but guard anyway
+  skip('ambiguous install path (project root equals package root)');
+}
+
+// 4. Build args
+const extra = process.env.AIGILE_INSTALL_ARGS ? process.env.AIGILE_INSTALL_ARGS.split(/\s+/).filter(Boolean) : [];
+const cliPath = path.join(pkgRoot, 'tools', 'cli.js');
+// Use 'install' command with --yes for non-interactive install
+const args = [cliPath, 'install', '--yes'];
+args.push(...extra);
+
+log(`Running automatic install into consumer project: ${projectRoot}`);
+log(`Command: node ${args.map(a => (a.includes(' ') ? '"'+a+'"' : a)).join(' ')}`);
+
+const child = spawn(process.execPath, args, {
+  cwd: projectRoot,
+  stdio: 'inherit',
+  env: process.env
+});
+
+child.on('exit', (code) => {
+  if(code === 0) log('AIgile installed successfully (postinstall).');
+  else warn(`AIgile postinstall exited with code ${code}. You can rerun: npx @mark-gozner/aigile-method install`);
+});

package/tools/shared/bannerArt.js

@@ -0,0 +1,68 @@
+// Simple ASCII banners for AIgile installer output (ESM)
+
+export const AIGILE_TITLE = 'AIgile-Method';
+export const INSTALLER_TITLE = 'INSTALLER';
+
+export const AIGILE_LARGE = `
+ █████╗ ██╗ ██████╗ ██╗██╗     ███████╗    ██╗███╗   ██╗███████╗████████╗ █████╗ ██╗     ██╗     ███████╗██████╗ 
+██╔══██╗██║██╔════╝ ██║██║     ██╔════╝    ██║████╗  ██║██╔════╝╚══██╔══╝██╔══██╗██║     ██║     ██╔════╝██╔══██╗
+███████║██║██║  ███╗██║██║     █████╗      ██║██╔██╗ ██║███████╗   ██║   ███████║██║     ██║     █████╗  ██████╔╝
+██╔══██║██║██║   ██║██║██║     ██╔══╝      ██║██║╚██╗██║╚════██║   ██║   ██╔══██║██║     ██║     ██╔══╝  ██╔══██╗
+██║  ██║██║╚██████╔╝██║███████╗███████╗    ██║██║ ╚████║███████║   ██║   ██║  ██║███████╗███████╗███████╗██║  ██║
+╚═╝  ╚═╝╚═╝ ╚═════╝ ╚═╝╚══════╝╚══════╝    ╚═╝╚═╝  ╚═══╝╚══════╝   ╚═╝   ╚═╝  ╚═╝╚══════╝╚══════╝╚══════╝╚═╝  ╚═╝
+                                                                                                                
+`;
+
+export const INSTALLER_SMALL = `
+╭──────────────────────────╮
+│     AIgile Installer     │
+╰──────────────────────────╯
+`;
+
+// GM signature banners
+export const GM_LARGE = `
+ ██████╗██████╗ ███████╗ █████╗ ████████╗███████╗██████╗     ██████╗ ██╗   ██╗     ██████╗ ███╗   ███╗
+██╔════╝██╔══██╗██╔════╝██╔══██╗╚══██╔══╝██╔════╝██╔══██╗    ██╔══██╗╚██╗ ██╔╝    ██╔════╝ ████╗ ████║
+██║     ██████╔╝█████╗  ███████║   ██║   █████╗  ██║  ██║    ██████╔╝ ╚████╔╝     ██║  ███╗██╔████╔██║
+██║     ██╔══██╗██╔══╝  ██╔══██║   ██║   ██╔══╝  ██║  ██║    ██╔══██╗  ╚██╔╝      ██║   ██║██║╚██╔╝██║
+╚██████╗██║  ██║███████╗██║  ██║   ██║   ███████╗██████╔╝    ██████╔╝   ██║       ╚██████╔╝██║ ╚═╝ ██║
+ ╚═════╝╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝   ╚═╝   ╚══════╝╚═════╝     ╚═════╝    ╚═╝        ╚═════╝ ╚═╝     ╚═╝
+                                                                                                      
+`;
+export const GM_MEDIUM = `
+╭──────────────────────────╮
+│     Created by GM        │
+╰──────────────────────────╯
+`;
+
+function applyGradient(text, startColor, endColor) {
+  const length = text.length;
+  let result = '';
+
+  for (let i = 0; i < length; i++) {
+    const char = text[i];
+    if (char === '\n') {
+      result += char;
+      continue;
+    }
+    const ratio = i / length;
+    const r = Math.round(startColor.r + ratio * (endColor.r - startColor.r));
+    const g = Math.round(startColor.g + ratio * (endColor.g - startColor.g));
+    const b = Math.round(startColor.b + ratio * (endColor.b - startColor.b));
+    result += `\x1b[38;2;${r};${g};${b}m${char}\x1b[0m`;
+  }
+
+  return result;
+}
+
+export function printInstallBanner({ showGMSignature = true } = {}) {
+  const neonGreen = { r: 57, g: 255, b: 20 };     // Neon green
+  const cyan = { r: 0, g: 255, b: 255 };          // Cyan
+  const magenta = { r: 255, g: 0, b: 255 };       // Magenta
+  const orange = { r: 255, g: 165, b: 0 };        // Orange
+
+  console.log('\n' + applyGradient(AIGILE_LARGE, neonGreen, cyan));
+  if (showGMSignature) {
+    console.log(applyGradient(GM_LARGE, magenta, orange));
+  }
+}

package/tools/validate-bundles.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const root = path.resolve(__dirname, '..');
+const dist = path.join(root, 'dist');
+
+function fail(msg){
+  console.error('❌', msg);
+  process.exitCode = 1;
+}
+
+function ok(msg){
+  console.log('✅', msg);
+}
+
+function mustExist(p){
+  if(!fs.existsSync(p)) fail(`Missing: ${path.relative(root, p)}`);
+  else ok(`Exists: ${path.relative(root, p)}`);
+}
+
+function checkMarkers(file){
+  const txt = fs.readFileSync(file, 'utf8');
+  if(!txt.includes('Web Agent Bundle Instructions')) fail(`${path.basename(file)} missing header`);
+  const startCount = (txt.match(/==================== START:/g) || []).length;
+  const endCount = (txt.match(/==================== END:/g) || []).length;
+  if(startCount === 0 || endCount === 0) fail(`${path.basename(file)} missing START/END markers`);
+  if(startCount !== endCount) fail(`${path.basename(file)} START/END count mismatch (${startCount} vs ${endCount})`);
+  else ok(`${path.basename(file)} markers balanced (${startCount})`);
+  if(!txt.includes('.aigile-core/')) fail(`${path.basename(file)} missing .aigile-core paths`);
+}
+
+function main(){
+  mustExist(dist);
+  const team = path.join(dist, 'teams', 'team-company.txt');
+  const agentsDir = path.join(dist, 'agents');
+  mustExist(team);
+  mustExist(agentsDir);
+  const dev = path.join(agentsDir, 'dev.txt');
+  if(fs.existsSync(dev)) ok('dev agent bundle present');
+  else console.warn('ℹ️ dev agent bundle not found (ok if no dev.md)');
+  checkMarkers(team);
+  if(fs.existsSync(dev)) checkMarkers(dev);
+
+  // Sanity: ensure team includes at least one agent file content by looking for core/agents/
+  const teamTxt = fs.readFileSync(team, 'utf8');
+  if(!teamTxt.includes('/agents/')) fail('team-company.txt does not seem to include any agent content');
+  else ok('team-company.txt includes agent content');
+}
+
+main();