claude-cli-advanced-starter-pack 1.0.16 → 1.8.0

package/templates/scripts/roadmap-scanner.js

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+/**
+ * Roadmap Scanner
+ *
+ * Scans for roadmap files and generates a progress dashboard.
+ * Detects phase status, completion percentages, and blockers.
+ *
+ * Usage:
+ *   node roadmap-scanner.js                  # Scan current directory
+ *   node roadmap-scanner.js --path ./docs    # Scan specific directory
+ *   node roadmap-scanner.js --output json    # JSON output
+ */
+
+import { readdirSync, readFileSync, statSync } from 'fs';
+import { join, basename } from 'path';
+
+const ROADMAP_PATTERNS = [
+  /roadmap/i,
+  /phase[-_]?dev/i,
+  /implementation[-_]?plan/i,
+  /project[-_]?plan/i,
+];
+
+const STATUS_PATTERNS = {
+  complete: [/✅/, /\[x\]/i, /complete/i, /done/i, /finished/i],
+  inProgress: [/🟨/, /\[ \]/, /in.?progress/i, /wip/i, /started/i],
+  blocked: [/❌/, /blocked/i, /stuck/i, /waiting/i],
+  notStarted: [/⬜/, /not.?started/i, /pending/i, /todo/i],
+};
+
+class RoadmapScanner {
+  constructor(options = {}) {
+    this.path = options.path || process.cwd();
+    this.output = options.output || 'text';
+    this.recursive = options.recursive !== false;
+    this.roadmaps = [];
+  }
+
+  async scan() {
+    console.log(`\n📋 Scanning for roadmaps in: ${this.path}\n`);
+
+    await this.findRoadmaps(this.path);
+
+    if (this.roadmaps.length === 0) {
+      console.log('No roadmap files found.');
+      return;
+    }
+
+    console.log(`Found ${this.roadmaps.length} roadmap(s)\n`);
+
+    for (const roadmap of this.roadmaps) {
+      await this.analyzeRoadmap(roadmap);
+    }
+
+    if (this.output === 'json') {
+      this.outputJson();
+    } else {
+      this.outputText();
+    }
+  }
+
+  async findRoadmaps(dir) {
+    try {
+      const entries = readdirSync(dir);
+
+      for (const entry of entries) {
+        const fullPath = join(dir, entry);
+        const stat = statSync(fullPath);
+
+        if (stat.isDirectory() && this.recursive) {
+          if (!entry.startsWith('.') && entry !== 'node_modules') {
+            await this.findRoadmaps(fullPath);
+          }
+        } else if (stat.isFile() && entry.endsWith('.md')) {
+          if (ROADMAP_PATTERNS.some(pattern => pattern.test(entry))) {
+            this.roadmaps.push({
+              path: fullPath,
+              name: basename(entry, '.md'),
+              phases: [],
+              metrics: {},
+            });
+          }
+        }
+      }
+    } catch (e) {
+      // Ignore access errors
+    }
+  }
+
+  async analyzeRoadmap(roadmap) {
+    const content = readFileSync(roadmap.path, 'utf8');
+    const lines = content.split('\n');
+
+    let currentPhase = null;
+    let totalTasks = 0;
+    let completedTasks = 0;
+    let blockedTasks = 0;
+
+    for (const line of lines) {
+      // Detect phase headers
+      const phaseMatch = line.match(/^#+\s*phase\s*(\d+)/i);
+      if (phaseMatch) {
+        if (currentPhase) {
+          roadmap.phases.push(currentPhase);
+        }
+        currentPhase = {
+          number: parseInt(phaseMatch[1]),
+          name: line.replace(/^#+\s*/, '').trim(),
+          status: 'not_started',
+          tasks: [],
+          notes: [],
+        };
+        continue;
+      }
+
+      // Detect status markers in phase headers or status tables
+      if (currentPhase) {
+        // Check for task markers
+        const taskMatch = line.match(/^\s*[-*]\s*\[([ x])\]/i);
+        if (taskMatch) {
+          totalTasks++;
+          const isComplete = taskMatch[1].toLowerCase() === 'x';
+          if (isComplete) completedTasks++;
+          currentPhase.tasks.push({
+            text: line.replace(/^\s*[-*]\s*\[[ x]\]\s*/i, ''),
+            complete: isComplete,
+          });
+        }
+
+        // Check for status indicators
+        for (const [status, patterns] of Object.entries(STATUS_PATTERNS)) {
+          if (patterns.some(p => p.test(line))) {
+            if (status === 'blocked') {
+              blockedTasks++;
+              currentPhase.status = 'blocked';
+            } else if (status === 'complete' && currentPhase.status !== 'blocked') {
+              currentPhase.status = 'complete';
+            } else if (status === 'inProgress' && !['complete', 'blocked'].includes(currentPhase.status)) {
+              currentPhase.status = 'in_progress';
+            }
+          }
+        }
+
+        // Check for version info
+        const versionMatch = line.match(/v?(\d+\.\d+\.\d+)/);
+        if (versionMatch) {
+          currentPhase.version = versionMatch[1];
+        }
+      }
+    }
+
+    // Add last phase
+    if (currentPhase) {
+      roadmap.phases.push(currentPhase);
+    }
+
+    // Calculate metrics
+    roadmap.metrics = {
+      totalPhases: roadmap.phases.length,
+      completedPhases: roadmap.phases.filter(p => p.status === 'complete').length,
+      inProgressPhases: roadmap.phases.filter(p => p.status === 'in_progress').length,
+      blockedPhases: roadmap.phases.filter(p => p.status === 'blocked').length,
+      totalTasks,
+      completedTasks,
+      blockedTasks,
+      progress: totalTasks > 0 ? Math.round((completedTasks / totalTasks) * 100) : 0,
+    };
+  }
+
+  outputText() {
+    console.log('='.repeat(70));
+    console.log('                         ROADMAP DASHBOARD');
+    console.log('='.repeat(70));
+
+    for (const roadmap of this.roadmaps) {
+      console.log(`\n📄 ${roadmap.name}`);
+      console.log(`   Path: ${roadmap.path}`);
+      console.log('-'.repeat(70));
+
+      // Progress bar
+      const progress = roadmap.metrics.progress;
+      const barLength = 40;
+      const filled = Math.round((progress / 100) * barLength);
+      const bar = '█'.repeat(filled) + '░'.repeat(barLength - filled);
+      console.log(`\n   Progress: [${bar}] ${progress}%`);
+
+      // Metrics
+      const m = roadmap.metrics;
+      console.log(`\n   Phases: ${m.completedPhases}/${m.totalPhases} complete`);
+      console.log(`   Tasks:  ${m.completedTasks}/${m.totalTasks} complete`);
+
+      if (m.blockedPhases > 0) {
+        console.log(`   ⚠️  ${m.blockedPhases} phase(s) blocked`);
+      }
+
+      // Phase details
+      console.log('\n   Phase Status:');
+      for (const phase of roadmap.phases) {
+        const icon = phase.status === 'complete' ? '✅' :
+                     phase.status === 'in_progress' ? '🔄' :
+                     phase.status === 'blocked' ? '❌' : '⬜';
+        const version = phase.version ? ` (v${phase.version})` : '';
+        console.log(`     ${icon} ${phase.name}${version}`);
+      }
+    }
+
+    // Summary
+    console.log('\n' + '='.repeat(70));
+    console.log('SUMMARY');
+    console.log('='.repeat(70));
+
+    const totals = this.roadmaps.reduce((acc, r) => ({
+      phases: acc.phases + r.metrics.totalPhases,
+      completed: acc.completed + r.metrics.completedPhases,
+      tasks: acc.tasks + r.metrics.totalTasks,
+      doneTasks: acc.doneTasks + r.metrics.completedTasks,
+    }), { phases: 0, completed: 0, tasks: 0, doneTasks: 0 });
+
+    console.log(`\n   Total Roadmaps: ${this.roadmaps.length}`);
+    console.log(`   Total Phases:   ${totals.completed}/${totals.phases} complete`);
+    console.log(`   Total Tasks:    ${totals.doneTasks}/${totals.tasks} complete`);
+    console.log(`   Overall:        ${totals.tasks > 0 ? Math.round((totals.doneTasks / totals.tasks) * 100) : 0}%`);
+    console.log('\n' + '='.repeat(70) + '\n');
+  }
+
+  outputJson() {
+    const output = {
+      scannedAt: new Date().toISOString(),
+      path: this.path,
+      roadmaps: this.roadmaps,
+      summary: {
+        totalRoadmaps: this.roadmaps.length,
+        totalPhases: this.roadmaps.reduce((acc, r) => acc + r.metrics.totalPhases, 0),
+        completedPhases: this.roadmaps.reduce((acc, r) => acc + r.metrics.completedPhases, 0),
+        totalTasks: this.roadmaps.reduce((acc, r) => acc + r.metrics.totalTasks, 0),
+        completedTasks: this.roadmaps.reduce((acc, r) => acc + r.metrics.completedTasks, 0),
+      },
+    };
+
+    console.log(JSON.stringify(output, null, 2));
+  }
+}
+
+// CLI entry point
+async function main() {
+  const args = process.argv.slice(2);
+
+  const getArg = (name) => {
+    const index = args.indexOf(`--${name}`);
+    return index >= 0 ? args[index + 1] : null;
+  };
+
+  const options = {
+    path: getArg('path') || process.cwd(),
+    output: getArg('output') || 'text',
+    recursive: !args.includes('--no-recursive'),
+  };
+
+  const scanner = new RoadmapScanner(options);
+  await scanner.scan();
+}
+
+main().catch(console.error);

package/templates/scripts/validate-deployment.js

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+/**
+ * Validate Deployment Environment
+ *
+ * Pre-deployment validation for Railway, Cloudflare, Vercel, and other platforms.
+ * Checks environment variables, build artifacts, and configuration.
+ *
+ * Usage:
+ *   node validate-deployment.js --platform railway
+ *   node validate-deployment.js --platform cloudflare --project-name my-project
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { resolve } from 'path';
+
+const PLATFORMS = {
+  railway: {
+    requiredEnv: ['RAILWAY_API_TOKEN'],
+    optionalEnv: ['RAILWAY_PROJECT_ID', 'RAILWAY_ENVIRONMENT_ID', 'RAILWAY_SERVICE_ID'],
+    buildArtifacts: ['package.json', 'Dockerfile', 'requirements.txt', 'go.mod'],
+    configFiles: ['railway.json', 'railway.toml'],
+  },
+  cloudflare: {
+    requiredEnv: ['CLOUDFLARE_API_TOKEN'],
+    optionalEnv: ['CLOUDFLARE_ACCOUNT_ID'],
+    buildArtifacts: ['dist/', 'build/', 'public/', '.next/'],
+    configFiles: ['wrangler.toml', 'wrangler.json'],
+  },
+  vercel: {
+    requiredEnv: ['VERCEL_TOKEN'],
+    optionalEnv: ['VERCEL_PROJECT_ID', 'VERCEL_ORG_ID'],
+    buildArtifacts: ['dist/', 'build/', '.next/', '.vercel/'],
+    configFiles: ['vercel.json'],
+  },
+  netlify: {
+    requiredEnv: ['NETLIFY_AUTH_TOKEN'],
+    optionalEnv: ['NETLIFY_SITE_ID'],
+    buildArtifacts: ['dist/', 'build/', 'public/'],
+    configFiles: ['netlify.toml'],
+  },
+};
+
+class DeploymentValidator {
+  constructor(platform, options = {}) {
+    this.platform = platform;
+    this.options = options;
+    this.config = PLATFORMS[platform];
+    this.errors = [];
+    this.warnings = [];
+    this.checks = [];
+  }
+
+  async validate() {
+    console.log(`\n🔍 Validating ${this.platform} deployment...\n`);
+
+    await this.checkEnvironmentVariables();
+    await this.checkBuildArtifacts();
+    await this.checkConfigFiles();
+    await this.checkGitStatus();
+    await this.platformSpecificChecks();
+
+    this.printReport();
+    return this.errors.length === 0;
+  }
+
+  async checkEnvironmentVariables() {
+    console.log('📋 Checking environment variables...');
+
+    for (const envVar of this.config.requiredEnv) {
+      if (process.env[envVar]) {
+        this.checks.push({ name: envVar, status: 'pass', message: 'Set' });
+      } else {
+        this.errors.push(`Missing required: ${envVar}`);
+        this.checks.push({ name: envVar, status: 'fail', message: 'Missing' });
+      }
+    }
+
+    for (const envVar of this.config.optionalEnv) {
+      if (process.env[envVar]) {
+        this.checks.push({ name: envVar, status: 'pass', message: 'Set (optional)' });
+      } else {
+        this.warnings.push(`Optional not set: ${envVar}`);
+        this.checks.push({ name: envVar, status: 'warn', message: 'Not set (optional)' });
+      }
+    }
+  }
+
+  async checkBuildArtifacts() {
+    console.log('📦 Checking build artifacts...');
+
+    let foundArtifact = false;
+    for (const artifact of this.config.buildArtifacts) {
+      const path = resolve(process.cwd(), artifact);
+      if (existsSync(path)) {
+        foundArtifact = true;
+        this.checks.push({ name: artifact, status: 'pass', message: 'Found' });
+      }
+    }
+
+    if (!foundArtifact) {
+      this.warnings.push('No build artifacts found. Run build command first.');
+    }
+  }
+
+  async checkConfigFiles() {
+    console.log('⚙️  Checking configuration files...');
+
+    let foundConfig = false;
+    for (const configFile of this.config.configFiles) {
+      const path = resolve(process.cwd(), configFile);
+      if (existsSync(path)) {
+        foundConfig = true;
+        this.checks.push({ name: configFile, status: 'pass', message: 'Found' });
+
+        // Validate config content
+        try {
+          const content = readFileSync(path, 'utf8');
+          if (configFile.endsWith('.json')) {
+            JSON.parse(content);
+            this.checks.push({ name: `${configFile} syntax`, status: 'pass', message: 'Valid JSON' });
+          }
+        } catch (e) {
+          this.errors.push(`Invalid ${configFile}: ${e.message}`);
+        }
+      }
+    }
+
+    if (!foundConfig) {
+      this.warnings.push(`No ${this.platform} config file found. Using defaults.`);
+    }
+  }
+
+  async checkGitStatus() {
+    console.log('🔀 Checking git status...');
+
+    try {
+      const { execSync } = await import('child_process');
+
+      // Check for uncommitted changes
+      const status = execSync('git status --porcelain', { encoding: 'utf8' });
+      if (status.trim()) {
+        this.warnings.push('Uncommitted changes detected. Consider committing first.');
+        this.checks.push({ name: 'Git status', status: 'warn', message: 'Uncommitted changes' });
+      } else {
+        this.checks.push({ name: 'Git status', status: 'pass', message: 'Clean' });
+      }
+
+      // Check branch
+      const branch = execSync('git branch --show-current', { encoding: 'utf8' }).trim();
+      this.checks.push({ name: 'Current branch', status: 'info', message: branch });
+
+    } catch (e) {
+      this.warnings.push('Not a git repository or git not available');
+    }
+  }
+
+  async platformSpecificChecks() {
+    switch (this.platform) {
+      case 'railway':
+        await this.checkRailway();
+        break;
+      case 'cloudflare':
+        await this.checkCloudflare();
+        break;
+      case 'vercel':
+        await this.checkVercel();
+        break;
+    }
+  }
+
+  async checkRailway() {
+    // Check for Dockerfile or supported runtime
+    const hasDockerfile = existsSync(resolve(process.cwd(), 'Dockerfile'));
+    const hasPackageJson = existsSync(resolve(process.cwd(), 'package.json'));
+    const hasRequirements = existsSync(resolve(process.cwd(), 'requirements.txt'));
+
+    if (!hasDockerfile && !hasPackageJson && !hasRequirements) {
+      this.errors.push('No supported runtime detected (Dockerfile, package.json, or requirements.txt)');
+    }
+
+    // Check for Railway-specific health check endpoint
+    if (hasPackageJson) {
+      try {
+        const pkg = JSON.parse(readFileSync('package.json', 'utf8'));
+        if (pkg.scripts?.start) {
+          this.checks.push({ name: 'Start script', status: 'pass', message: pkg.scripts.start });
+        } else {
+          this.warnings.push('No "start" script in package.json');
+        }
+      } catch (e) {
+        // Ignore
+      }
+    }
+  }
+
+  async checkCloudflare() {
+    const { projectName } = this.options;
+
+    // Check dist folder
+    const distPath = resolve(process.cwd(), 'dist');
+    if (!existsSync(distPath)) {
+      this.errors.push('dist/ folder not found. Run "npm run build" first.');
+    }
+
+    // Check for index.html in dist
+    const indexPath = resolve(distPath, 'index.html');
+    if (existsSync(distPath) && !existsSync(indexPath)) {
+      this.warnings.push('No index.html in dist/. Is this a static site?');
+    }
+
+    // Validate wrangler.toml if exists
+    const wranglerPath = resolve(process.cwd(), 'wrangler.toml');
+    if (existsSync(wranglerPath)) {
+      const content = readFileSync(wranglerPath, 'utf8');
+      if (projectName && !content.includes(projectName)) {
+        this.warnings.push(`Project name "${projectName}" not found in wrangler.toml`);
+      }
+    }
+  }
+
+  async checkVercel() {
+    // Check for .vercel folder
+    const vercelDir = resolve(process.cwd(), '.vercel');
+    if (!existsSync(vercelDir)) {
+      this.warnings.push('No .vercel folder. Run "vercel link" first.');
+    }
+  }
+
+  printReport() {
+    console.log('\n' + '='.repeat(60));
+    console.log(`📊 Validation Report: ${this.platform.toUpperCase()}`);
+    console.log('='.repeat(60));
+
+    // Print checks
+    console.log('\nChecks:');
+    for (const check of this.checks) {
+      const icon = check.status === 'pass' ? '✅' :
+                   check.status === 'fail' ? '❌' :
+                   check.status === 'warn' ? '⚠️' : 'ℹ️';
+      console.log(`  ${icon} ${check.name}: ${check.message}`);
+    }
+
+    // Print errors
+    if (this.errors.length > 0) {
+      console.log('\n❌ Errors:');
+      for (const error of this.errors) {
+        console.log(`   - ${error}`);
+      }
+    }
+
+    // Print warnings
+    if (this.warnings.length > 0) {
+      console.log('\n⚠️  Warnings:');
+      for (const warning of this.warnings) {
+        console.log(`   - ${warning}`);
+      }
+    }
+
+    // Summary
+    console.log('\n' + '-'.repeat(60));
+    if (this.errors.length === 0) {
+      console.log('✅ Validation PASSED - Ready to deploy');
+    } else {
+      console.log(`❌ Validation FAILED - ${this.errors.length} error(s) found`);
+    }
+    console.log('-'.repeat(60) + '\n');
+  }
+}
+
+// CLI entry point
+async function main() {
+  const args = process.argv.slice(2);
+  const platformIndex = args.indexOf('--platform');
+  const platform = platformIndex >= 0 ? args[platformIndex + 1] : null;
+
+  if (!platform || !PLATFORMS[platform]) {
+    console.error('Usage: node validate-deployment.js --platform <railway|cloudflare|vercel|netlify>');
+    console.error('Available platforms:', Object.keys(PLATFORMS).join(', '));
+    process.exit(1);
+  }
+
+  const options = {};
+  const projectNameIndex = args.indexOf('--project-name');
+  if (projectNameIndex >= 0) {
+    options.projectName = args[projectNameIndex + 1];
+  }
+
+  const validator = new DeploymentValidator(platform, options);
+  const success = await validator.validate();
+  process.exit(success ? 0 : 1);
+}
+
+main().catch(console.error);

package/templates/skills/agent-creator/skill.json

@@ -0,0 +1,18 @@
+{
+  "name": "agent-creator",
+  "version": "1.0.0",
+  "description": "Create Claude Code CLI agents (subagents) following best practices",
+  "category": "development",
+  "portability": 100,
+  "features": [
+    "Task tool configuration",
+    "Agent specialization patterns",
+    "Workflow integration",
+    "RAG-enhanced knowledge bases"
+  ],
+  "entryPoint": "skill.md",
+  "context": [],
+  "workflows": [],
+  "requiredTools": ["Task", "Read", "Glob", "Grep"],
+  "suggestedModel": "sonnet"
+}