workspace-maxxing 0.1.0

package/src/platforms/claude.ts

@@ -0,0 +1,40 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { PlatformInstaller } from './index';
+
+export class ClaudeInstaller implements PlatformInstaller {
+  install(agentPath: string, targetDir: string): void {
+    // Claude Code expects: .claude/skills/<name>/SKILL.md
+    // Need to remove @ prefix for directory name
+    
+    const agentName = path.basename(agentPath);
+    const cleanName = agentName.startsWith('@') ? agentName.slice(1) : agentName;
+    const targetPath = path.join(targetDir, '.claude', 'skills', cleanName);
+    
+    // Ensure target directory exists
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    
+    this.copyDir(agentPath, targetPath);
+    console.log(`[Claude] Installed ${cleanName} at: ${targetPath}`);
+  }
+
+  getAgentDir(workspacePath: string): string {
+    return path.join(workspacePath, '.claude', 'skills');
+  }
+
+  private copyDir(src: string, dest: string): void {
+    fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+      
+      if (entry.isDirectory()) {
+        this.copyDir(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+}

package/src/platforms/copilot.ts

@@ -0,0 +1,50 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { PlatformInstaller } from './index';
+
+export class CopilotInstaller implements PlatformInstaller {
+  install(agentPath: string, targetDir: string): void {
+    // Copilot expects: .github/copilot-instructions/<name>.md
+    // Convert SKILL.md content to markdown instructions
+    
+    const agentName = path.basename(agentPath);
+    const cleanName = agentName.startsWith('@') ? agentName.slice(1) : agentName;
+    const targetPath = path.join(targetDir, '.github', 'copilot-instructions', `${cleanName}.md`);
+    
+    // Ensure target directory exists
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    
+    // Convert skill to copilot instructions format
+    const skillMdPath = path.join(agentPath, 'SKILL.md');
+    const skillMd = fs.existsSync(skillMdPath) 
+      ? fs.readFileSync(skillMdPath, 'utf-8') 
+      : '# Agent\n\nWorkflow agent';
+    const instructions = this.convertToCopilotInstructions(skillMd, cleanName);
+    
+    fs.writeFileSync(targetPath, instructions);
+    console.log(`[Copilot] Installed ${cleanName} at: ${targetPath}`);
+  }
+
+  getAgentDir(workspacePath: string): string {
+    return path.join(workspacePath, '.github', 'copilot-instructions');
+  }
+
+  private convertToCopilotInstructions(skillMd: string, agentName: string): string {
+    // Extract description from SKILL.md
+    const descMatch = skillMd.match(/^description:\s*"(.+)"$/m);
+    const triggersMatch = skillMd.match(/^triggers:\s*\[(.+)\]/m);
+    
+    const desc = descMatch ? descMatch[1] : 'Workflow agent';
+    const triggers = triggersMatch ? triggersMatch[1].replace(/["']/g, '').split(',') : [];
+    
+    let output = `# ${agentName}\n\n${desc}\n\n`;
+    
+    if (triggers.length > 0) {
+      output += `## Trigger Phrases\n\n${triggers.map(t => `- ${t.trim()}`).join('\n')}\n\n`;
+    }
+    
+    output += `## Usage\n\nUse this agent when working with the workspace workflow. Simply mention @${agentName} or use the trigger phrases above.\n\n## Capabilities\n\n- Execute workflow tasks following ICM stage boundaries\n- Process inputs and generate outputs\n- Produce structured markdown artifacts\n`;
+    
+    return output;
+  }
+}

package/src/platforms/gemini.ts

@@ -0,0 +1,55 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { PlatformInstaller } from './index';
+
+export class GeminiInstaller implements PlatformInstaller {
+  install(agentPath: string, targetDir: string): void {
+    // Gemini expects: .gemini/skills/<name>/instructions.md
+    
+    const agentName = path.basename(agentPath);
+    const cleanName = agentName.startsWith('@') ? agentName.slice(1) : agentName;
+    const targetPath = path.join(targetDir, '.gemini', 'skills', cleanName, 'instructions.md');
+    
+    // Ensure target directory exists
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    
+    // Convert SKILL.md to Gemini instructions format
+    const skillMdPath = path.join(agentPath, 'SKILL.md');
+    const skillMd = fs.existsSync(skillMdPath) 
+      ? fs.readFileSync(skillMdPath, 'utf-8') 
+      : '# Agent\n\nWorkflow agent';
+    const instructions = this.convertToGeminiInstructions(skillMd);
+    
+    fs.writeFileSync(targetPath, instructions);
+    console.log(`[Gemini] Installed ${cleanName} at: ${targetPath}`);
+  }
+
+  getAgentDir(workspacePath: string): string {
+    return path.join(workspacePath, '.gemini', 'skills');
+  }
+
+  private convertToGeminiInstructions(skillMd: string): string {
+    // Extract key sections from SKILL.md
+    const nameMatch = skillMd.match(/^name:\s*(.+)$/m);
+    const descMatch = skillMd.match(/^description:\s*"(.+)"$/m);
+    const triggersMatch = skillMd.match(/^triggers:\s*\[(.+)\]/m);
+    
+    const name = nameMatch ? nameMatch[1] : 'Agent';
+    const desc = descMatch ? descMatch[1] : 'Workflow agent';
+    const triggers = triggersMatch 
+      ? triggersMatch[1].replace(/["']/g, '').split(',').map(t => t.trim()) 
+      : [];
+    
+    let output = `# ${name}\n\n${desc}\n\n## How to Invoke\n\n`;
+    
+    if (triggers.length > 0) {
+      output += `Use one of these phrases:\n${triggers.map(t => `- "${t}"`).join('\n')}\n\n`;
+    } else {
+      output += `Invoke the agent by name.\n\n`;
+    }
+    
+    output += `## Capabilities\n\n- Execute workflow tasks\n- Process inputs and generate outputs\n- Follow ICM stage boundaries\n- Produce markdown artifacts\n\n## Workflow Context\n\nWhen activated, this agent operates within the workspace context:\n- Read SYSTEM.md first\n- Load relevant stage CONTEXT.md\n- Execute the requested task\n- Produce outputs in appropriate folders\n`;
+    
+    return output;
+  }
+}

package/src/platforms/index.ts

@@ -0,0 +1,45 @@
+export type Platform = 'opencode' | 'claude' | 'copilot' | 'gemini';
+
+export interface PlatformInstaller {
+  install(agentPath: string, targetDir: string): void;
+  getAgentDir(workspacePath: string): string;
+}
+
+export function detectPlatform(): Platform {
+  // Check for platform-specific env vars or files
+  if (process.env.OPENCODE_SESSION || process.env.AGENT_MODE === 'opencode') {
+    return 'opencode';
+  }
+  if (process.env.CLAUDE_CODE || process.env.CLAUDE_SESSION) {
+    return 'claude';
+  }
+  if (process.env.COPILOT_AGENT) {
+    return 'copilot';
+  }
+  if (process.env.GEMINI_CLI) {
+    return 'gemini';
+  }
+  // Default to opencode for now
+  return 'opencode';
+}
+
+export function getPlatformInstaller(platform: Platform): PlatformInstaller {
+  switch (platform) {
+    case 'opencode':
+      return new OpenCodeInstaller();
+    case 'claude':
+      return new ClaudeInstaller();
+    case 'copilot':
+      return new CopilotInstaller();
+    case 'gemini':
+      return new GeminiInstaller();
+    default:
+      throw new Error(`Unknown platform: ${platform}`);
+  }
+}
+
+// Import and re-export all platform installers
+import { OpenCodeInstaller } from './opencode';
+import { ClaudeInstaller } from './claude';
+import { CopilotInstaller } from './copilot';
+import { GeminiInstaller } from './gemini';

package/src/platforms/opencode.ts

@@ -0,0 +1,41 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { PlatformInstaller } from './index';
+
+export class OpenCodeInstaller implements PlatformInstaller {
+  install(agentPath: string, targetDir: string): void {
+    // OpenCode expects: .agents/skills/@agent-name/SKILL.md
+    // Already in correct format from agent-creator
+    
+    const agentName = path.basename(agentPath);
+    const targetPath = path.join(targetDir, '.agents', 'skills', agentName);
+    
+    // Ensure target directory exists
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    
+    // Copy entire agent directory
+    this.copyDir(agentPath, targetPath);
+    
+    console.log(`[OpenCode] Installed @${agentName} at: ${targetPath}`);
+  }
+
+  getAgentDir(workspacePath: string): string {
+    return path.join(workspacePath, '.agents', 'skills');
+  }
+
+  private copyDir(src: string, dest: string): void {
+    fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+      
+      if (entry.isDirectory()) {
+        this.copyDir(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+}

package/src/scripts/benchmark.ts

@@ -0,0 +1,171 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface StageBenchmark {
+  name: string;
+  raw: number;
+  weight: number;
+  weighted: number;
+}
+
+export interface BenchmarkResult {
+  workspace: string;
+  agent: string;
+  timestamp: string;
+  rawScore: number;
+  weightedScore: number;
+  stages: StageBenchmark[];
+  fixSuggestions: string[];
+  improvementPotential: boolean;
+}
+
+const STAGE_WEIGHTS: Record<string, number> = {
+  '01-ideation': 1.5,
+  '02-research': 1.3,
+  '03-architecture': 1.2,
+};
+
+const DEFAULT_WEIGHT = 1.0;
+const MAX_RAW_SCORE = 45;
+
+export function calculateBenchmark(workspacePath: string): BenchmarkResult {
+  const ws = path.resolve(workspacePath);
+  const stageFolders = getNumberedFolders(ws);
+
+  const stages: StageBenchmark[] = [];
+  let totalWeighted = 0;
+  let totalWeight = 0;
+
+  for (const folder of stageFolders) {
+    const weight = STAGE_WEIGHTS[folder] ?? DEFAULT_WEIGHT;
+    const raw = calculateStageRawScore(ws, folder);
+    const weighted = (raw / MAX_RAW_SCORE) * 100 * weight;
+
+    stages.push({ name: folder, raw, weight, weighted });
+    totalWeighted += weighted;
+    totalWeight += weight;
+  }
+
+  const weightedScore = totalWeight > 0 ? totalWeighted / totalWeight : 0;
+  const rawScore = stages.reduce((sum, s) => sum + s.raw, 0);
+
+  const fixSuggestions = stages
+    .filter((s) => s.raw < MAX_RAW_SCORE)
+    .map((s) => `Improve ${s.name}: current score ${s.raw}/${MAX_RAW_SCORE}`);
+
+  return {
+    workspace: path.basename(ws),
+    agent: 'unknown',
+    timestamp: new Date().toISOString(),
+    rawScore,
+    weightedScore: Math.min(Math.round(weightedScore), 100),
+    stages,
+    fixSuggestions,
+    improvementPotential: stages.some((s) => s.raw < MAX_RAW_SCORE),
+  };
+}
+
+export function formatBenchmarkTable(data: BenchmarkResult): string {
+  const lines: string[] = [];
+
+  lines.push(`\nBenchmark Report: ${data.workspace}`);
+  lines.push(`Agent: ${data.agent} | Timestamp: ${data.timestamp}`);
+  lines.push('');
+  lines.push(
+    padRight('Stage', 20) +
+    padRight('Raw', 8) +
+    padRight('Weight', 10) +
+    padRight('Weighted', 12)
+  );
+  lines.push('-'.repeat(50));
+
+  for (const stage of data.stages) {
+    lines.push(
+      padRight(stage.name, 20) +
+      padRight(String(stage.raw), 8) +
+      padRight(stage.weight.toFixed(1) + 'x', 10) +
+      padRight(stage.weighted.toFixed(1), 12)
+    );
+  }
+
+  lines.push('-'.repeat(50));
+  lines.push(
+    padRight('TOTAL', 20) +
+    padRight(String(data.rawScore), 8) +
+    padRight('', 10) +
+    padRight(data.weightedScore.toFixed(1), 12)
+  );
+  lines.push('');
+
+  if (data.fixSuggestions.length > 0) {
+    lines.push('Suggestions:');
+    for (const suggestion of data.fixSuggestions) {
+      lines.push(`  - ${suggestion}`);
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+export function saveBenchmarkReport(workspacePath: string, data: BenchmarkResult): string {
+  const reportDir = path.join(workspacePath, '.workspace-benchmarks');
+  fs.mkdirSync(reportDir, { recursive: true });
+
+  const filename = `${data.workspace}-${data.timestamp.replace(/[:.]/g, '-')}.json`;
+  const filePath = path.join(reportDir, filename);
+
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+  return filePath;
+}
+
+function calculateStageRawScore(ws: string, folder: string): number {
+  const stageContextPath = path.join(ws, folder, 'CONTEXT.md');
+  let score = 0;
+
+  if (fs.existsSync(stageContextPath)) {
+    const content = fs.readFileSync(stageContextPath, 'utf-8');
+    if (content.toLowerCase().includes('purpose') || content.toLowerCase().includes('## purpose')) score += 4;
+    if (content.toLowerCase().includes('input')) score += 4;
+    if (content.toLowerCase().includes('output')) score += 4;
+    if (content.toLowerCase().includes('dependenc')) score += 3;
+    if (content.toLowerCase().includes('## success criteria') || content.toLowerCase().includes('success criteria')) score += 5;
+    if (content.toLowerCase().includes('## approach') || content.toLowerCase().includes('approach')) score += 5;
+    if (content.toLowerCase().includes('## risks') || content.toLowerCase().includes('risks')) score += 5;
+    if (content.toLowerCase().includes('## timeline') || content.toLowerCase().includes('timeline')) score += 5;
+    if (content.toLowerCase().includes('## resources') || content.toLowerCase().includes('resources')) score += 5;
+    if (content.toLowerCase().includes('## validation') || content.toLowerCase().includes('validation')) score += 5;
+  }
+
+  return Math.min(score, MAX_RAW_SCORE);
+}
+
+function getNumberedFolders(workspacePath: string): string[] {
+  if (!fs.existsSync(workspacePath)) return [];
+  const entries = fs.readdirSync(workspacePath, { withFileTypes: true });
+  return entries
+    .filter((e) => e.isDirectory() && /^\d{2}-/.test(e.name) && e.name !== '00-meta')
+    .map((e) => e.name);
+}
+
+function padRight(str: string, length: number): string {
+  return str.padEnd(length);
+}
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const parseArg = (flag: string): string | undefined => {
+    const idx = args.indexOf(flag);
+    return idx !== -1 ? args[idx + 1] : undefined;
+  };
+
+  const workspace = parseArg('--workspace');
+
+  if (!workspace) {
+    console.error('Usage: node benchmark.ts --workspace <path>');
+    process.exit(1);
+  }
+
+  const result = calculateBenchmark(workspace);
+  console.log(formatBenchmarkTable(result));
+}