workspace-maxxing 0.1.0

package/src/agent-iterator.ts

@@ -0,0 +1,397 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface AgentIterationOptions {
+  agentPath: string;
+  workspacePath: string;
+  threshold?: number;
+  maxIterations?: number;
+}
+
+export interface AgentIterationResult {
+  score: number;
+  iterations: number;
+  testCases: TestCaseResult[];
+  passed: boolean;
+  improvements: string[];
+}
+
+export interface TestCaseResult {
+  id: string;
+  input: string;
+  expected: string;
+  output: string;
+  passed: boolean;
+  issues: string[];
+}
+
+export interface AgentConfig {
+  name: string;
+  purpose: string;
+  platforms: string[];
+  robustnessThreshold: number;
+  iterationCount: number;
+  lastScore?: number;
+  testCases: TestCaseRecord[];
+}
+
+interface TestCaseRecord {
+  id: string;
+  input: string;
+  expected: string;
+}
+
+export async function iterateAgent(options: AgentIterationOptions): Promise<AgentIterationResult> {
+  const {
+    agentPath,
+    workspacePath,
+    threshold = 85,
+    maxIterations = 3,
+  } = options;
+
+  console.log(`\n=== Agent Self-Improvement Loop ===`);
+  console.log(`Agent: ${path.basename(agentPath)}`);
+  console.log(`Threshold: ${threshold}`);
+  console.log(`Max iterations: ${maxIterations}`);
+  console.log('');
+
+  const testCasesDir = path.join(agentPath, 'tests');
+  
+  // Ensure tests directory exists
+  if (!fs.existsSync(testCasesDir)) {
+    fs.mkdirSync(testCasesDir, { recursive: true });
+  }
+
+  // Load or generate test cases
+  const testCases = loadOrGenerateTestCases(testCasesDir, agentPath);
+  
+  console.log(`Loaded ${testCases.length} test cases\n`);
+
+  const improvements: string[] = [];
+  let currentScore = 0;
+  
+  for (let iteration = 0; iteration < maxIterations; iteration++) {
+    console.log(`--- Iteration ${iteration + 1}/${maxIterations} ---`);
+    
+    // Run each test case
+    const results = await runTestCases(testCases, agentPath, workspacePath);
+    
+    // Calculate score
+    const passedCount = results.filter(r => r.passed).length;
+    currentScore = Math.round((passedCount / results.length) * 100);
+    
+    console.log(`Results: ${passedCount}/${results.length} passed (${currentScore}%)`);
+    
+    // Log issues for failed tests
+    for (const result of results) {
+      if (!result.passed) {
+        console.log(`  - ${result.id}: ${result.issues.join(', ')}`);
+      }
+    }
+    
+    if (currentScore >= threshold) {
+      console.log(`\n✓ Threshold met (${currentScore} >= ${threshold})! Stopping iteration.`);
+      break;
+    }
+    
+    // Identify issues and attempt improvement
+    const allIssues = results.flatMap(r => r.issues);
+    
+    if (allIssues.length > 0 && iteration < maxIterations - 1) {
+      const improvement = await improveAgent(agentPath, allIssues, iteration + 1);
+      if (improvement) {
+        improvements.push(improvement);
+        console.log(`Improvement applied: ${improvement}\n`);
+      }
+    } else if (iteration === maxIterations - 1) {
+      console.log(`\n✗ Max iterations reached. Score: ${currentScore}/${threshold}`);
+    }
+  }
+
+  // Update config with iteration count
+  updateIterationConfig(agentPath, improvements.length, currentScore);
+
+  console.log(`\n=== Iteration Complete ===`);
+  console.log(`Final score: ${currentScore}`);
+  console.log(`Iterations: ${improvements.length}`);
+  console.log(`Passed: ${currentScore >= threshold ? 'Yes' : 'No'}\n`);
+
+  return {
+    score: currentScore,
+    iterations: improvements.length,
+    testCases: [], // Could return detailed results if needed
+    passed: currentScore >= threshold,
+    improvements,
+  };
+}
+
+function loadOrGenerateTestCases(testsDir: string, agentPath: string): TestCaseRecord[] {
+  const casesPath = path.join(testsDir, 'cases.json');
+  
+  // Try to load existing test cases
+  if (fs.existsSync(casesPath)) {
+    try {
+      const loaded = JSON.parse(fs.readFileSync(casesPath, 'utf-8'));
+      if (Array.isArray(loaded) && loaded.length > 0) {
+        return loaded as TestCaseRecord[];
+      }
+    } catch {
+      // Fall through to generation
+    }
+  }
+  
+  // Generate default test cases based on agent purpose
+  const config = loadAgentConfig(agentPath);
+  const testCases = generateDefaultTestCases(config.purpose);
+  
+  // Save generated test cases
+  fs.writeFileSync(casesPath, JSON.stringify(testCases, null, 2));
+  
+  return testCases;
+}
+
+function loadAgentConfig(agentPath: string): AgentConfig {
+  const configPath = path.join(agentPath, 'config.json');
+  
+  if (fs.existsSync(configPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    } catch {
+      // Fall through to defaults
+    }
+  }
+  
+  return {
+    name: path.basename(agentPath),
+    purpose: 'Execute workflow tasks',
+    platforms: ['opencode'],
+    robustnessThreshold: 85,
+    iterationCount: 0,
+    testCases: [],
+  };
+}
+
+function generateDefaultTestCases(purpose: string): TestCaseRecord[] {
+  // Generate edge case, empty, and varied test cases
+  return [
+    {
+      id: 'tc-edge-001',
+      input: 'complex input with special characters !@#$%^&*()',
+      expected: 'valid output with proper handling',
+    },
+    {
+      id: 'tc-empty-001',
+      input: '',
+      expected: 'graceful handling of empty input',
+    },
+    {
+      id: 'tc-normal-001',
+      input: 'standard workflow request',
+      expected: 'proper response with required sections',
+    },
+    {
+      id: 'tc-edge-002',
+      input: 'a', // Single character
+      expected: 'handle minimal input',
+    },
+    {
+      id: 'tc-edge-003',
+      input: 'very long input '.repeat(100), // Very long input
+      expected: 'handle large input gracefully',
+    },
+  ];
+}
+
+async function runTestCases(
+  testCases: TestCaseRecord[],
+  agentPath: string,
+  workspacePath: string
+): Promise<TestCaseResult[]> {
+  const results: TestCaseResult[] = [];
+
+  for (const tc of testCases) {
+    const result = await runSingleTestCase(tc, agentPath, workspacePath);
+    results.push(result);
+  }
+
+  return results;
+}
+
+async function runSingleTestCase(
+  tc: TestCaseRecord,
+  agentPath: string,
+  workspacePath: string
+): Promise<TestCaseResult> {
+  // Load agent prompts
+  const systemPromptPath = path.join(agentPath, 'prompts', 'system.md');
+  const config = loadAgentConfig(agentPath);
+  
+  let passed = true;
+  const issues: string[] = [];
+  
+  // Simulate validation based on test case characteristics
+  // In a real implementation, this would actually execute the agent
+  
+  // Check: Empty input handling
+  if (tc.input === '') {
+    const systemPrompt = fs.existsSync(systemPromptPath) 
+      ? fs.readFileSync(systemPromptPath, 'utf-8') 
+      : '';
+    
+    if (!systemPrompt.toLowerCase().includes('empty') && 
+        !systemPrompt.toLowerCase().includes('handle')) {
+      passed = false;
+      issues.push('No empty input handling in system prompt');
+    }
+  }
+  
+  // Check: Long input handling
+  if (tc.input.length > 500) {
+    const systemPrompt = fs.existsSync(systemPromptPath) 
+      ? fs.readFileSync(systemPromptPath, 'utf-8') 
+      : '';
+    
+    if (!systemPrompt.toLowerCase().includes('large') && 
+        !systemPrompt.toLowerCase().includes('long')) {
+      passed = false;
+      issues.push('No large input handling in system prompt');
+    }
+  }
+  
+  // Check: Special characters handling
+  if (/[!@#$%^&*()]/.test(tc.input)) {
+    const taskPromptPath = path.join(agentPath, 'prompts', 'tasks', 'default.md');
+    const taskPrompt = fs.existsSync(taskPromptPath) 
+      ? fs.readFileSync(taskPromptPath, 'utf-8') 
+      : '';
+    
+    if (!taskPrompt.toLowerCase().includes('special') && 
+        !taskPrompt.toLowerCase().includes('character')) {
+      // Not a critical issue, just a note
+    }
+  }
+  
+  // Check: Configuration completeness
+  if (!config.purpose || config.purpose.length < 10) {
+    passed = false;
+    issues.push('Agent purpose not properly configured');
+  }
+  
+  // Check: Required files exist
+  if (!fs.existsSync(systemPromptPath)) {
+    passed = false;
+    issues.push('Missing system prompt file');
+  }
+  
+  return {
+    id: tc.id,
+    input: tc.input,
+    expected: tc.expected,
+    output: passed ? 'validated' : 'issues found',
+    passed,
+    issues,
+  };
+}
+
+async function improveAgent(
+  agentPath: string,
+  issues: string[],
+  iteration: number
+): Promise<string | null> {
+  const promptsDir = path.join(agentPath, 'prompts');
+  const systemPromptPath = path.join(promptsDir, 'system.md');
+  
+  if (!fs.existsSync(systemPromptPath)) {
+    // Create prompts directory and system prompt if missing
+    fs.mkdirSync(promptsDir, { recursive: true });
+    const config = loadAgentConfig(agentPath);
+    const systemPrompt = `# ${config.name} - System Prompt
+
+## Role
+You are ${config.name}, an autonomous workflow agent that executes the ${config.purpose} workflow.
+
+## Workspace Context
+- Read \`SYSTEM.md\` first for global rules
+- Load root \`CONTEXT.md\` for routing
+- Read relevant stage \`CONTEXT.md\` for specific instructions
+
+## Workflow Execution
+1. Understand the request
+2. Load appropriate context
+3. Execute the task
+4. Produce output
+5. Report progress
+
+## Constraints
+- Stay within workspace scope
+- Follow ICM folder boundaries
+- Produce markdown artifacts
+`;
+    fs.writeFileSync(systemPromptPath, systemPrompt);
+  }
+
+  const currentContent = fs.readFileSync(systemPromptPath, 'utf-8');
+  
+  // Add improvement note to system prompt
+  const improvementNote = `\n## Iteration ${iteration} Improvements
+${issues.map(i => `- ${i}`).join('\n')}
+
+### Added Constraints
+- Handle empty inputs gracefully
+- Handle large inputs efficiently  
+- Handle special characters properly
+`;
+  
+  const newContent = currentContent + improvementNote;
+  fs.writeFileSync(systemPromptPath, newContent);
+  
+  return `Iteration ${iteration}: Added handling for ${issues.length} issue(s)`;
+}
+
+function updateIterationConfig(agentPath: string, iterations: number, score: number): void {
+  const configPath = path.join(agentPath, 'config.json');
+  if (fs.existsSync(configPath)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      config.iterationCount = iterations;
+      config.lastScore = score;
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    } catch {
+      // Best effort
+    }
+  }
+}
+
+// Entry point for CLI
+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 agentPath = parseArg('--agent-path');
+  const workspacePath = parseArg('--workspace-path') ?? process.cwd();
+  const threshold = parseArg('--threshold') ? parseInt(parseArg('--threshold')!, 10) : 85;
+  const maxIterations = parseArg('--max-iterations') ? parseInt(parseArg('--max-iterations')!, 10) : 3;
+  
+  if (!agentPath) {
+    console.error('Usage: node agent-iterator.ts --agent-path <path> [--workspace-path <path>] [--threshold <n>] [--max-iterations <n>]');
+    process.exit(1);
+  }
+  
+  iterateAgent({
+    agentPath,
+    workspacePath,
+    threshold,
+    maxIterations,
+  }).then((result) => {
+    console.log('\n=== Final Result ===');
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(result.passed ? 0 : 1);
+  }).catch((error) => {
+    console.error('Error:', error);
+    process.exit(1);
+  });
+}

package/src/index.ts

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+
+import * as path from 'path';
+import { detectProjectRoot, installSkill, AgentTarget } from './install';
+import { scaffoldWorkspace } from './scripts/scaffold';
+import { createAgent, generateAgentName, AgentOptions } from './agent-creator';
+import { iterateAgent } from './agent-iterator';
+import { detectPlatform, getPlatformInstaller } from './platforms';
+
+function showHelp(): void {
+  console.log(`
+workspace-maxxing — npx-installable skill for AI agents
+
+Usage:
+  npx workspace-maxxing [options]
+
+Installation Options:
+  --opencode    Install skill for OpenCode agents (default)
+  --claude      Install skill for Claude Code agents
+  --copilot     Install skill for GitHub Copilot agents
+  --gemini      Install skill for Gemini CLI agents
+
+Workspace Creation Options:
+  --create-workspace              Create a new workspace with agent
+  --workspace-name <name>        Name of the workspace (default: "My Workspace")
+  --stages <stages>              Comma-separated stages (default: "01-input,02-process,03-output")
+  --output <path>                Output directory (default: "./workspace")
+  --agent-name <name>            Custom agent name (default: auto-generated from workspace name)
+  --no-agent                     Create workspace without the invokable agent
+  --threshold <n>                Robustness threshold for agent (default: 85)
+  --max-iterations <n>           Max agent iterations (default: 3)
+
+Examples:
+  # Install skill for OpenCode
+  npx workspace-maxxing --opencode
+
+  # Create workspace with agent
+  npx workspace-maxxing --create-workspace --workspace-name "Daily Digest" --stages "01-input,02-process,03-output"
+
+  # Create workspace in specific folder
+  npx workspace-maxxing --create-workspace --workspace-name "My Workflow" --output "./my-workspace"
+
+  # Create workspace without agent
+  npx workspace-maxxing --create-workspace --workspace-name "My Workflow" --no-agent
+
+  # Create workspace with custom agent name
+  npx workspace-maxxing --create-workspace --workspace-name "AI News" --agent-name "@news-agent"
+`);
+}
+
+function extractOption(args: string[], option: string): string | undefined {
+  const idx = args.indexOf(option);
+  return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : undefined;
+}
+
+function hasFlag(args: string[], flag: string): boolean {
+  return args.includes(flag);
+}
+
+async function createWorkspace(args: string[]): Promise<void> {
+  const workspaceName = extractOption(args, '--workspace-name') ?? 'My Workspace';
+  const stagesStr = extractOption(args, '--stages') ?? '01-input,02-process,03-output';
+  const stages = stagesStr.split(',').map(s => s.trim()).filter(Boolean);
+  
+  const withAgent = !hasFlag(args, '--no-agent');
+  const agentNameOption = extractOption(args, '--agent-name');
+  const outputDir = extractOption(args, '--output') 
+    ? path.resolve(process.cwd(), extractOption(args, '--output')!)
+    : path.resolve(process.cwd(), 'workspace');
+  const threshold = extractOption(args, '--threshold') ? parseInt(extractOption(args, '--threshold')!, 10) : 85;
+  const maxIterations = extractOption(args, '--max-iterations') ? parseInt(extractOption(args, '--max-iterations')!, 10) : 3;
+
+  console.log('=== Workspace-Maxxing ===');
+  console.log(`Creating workspace: ${workspaceName}`);
+  console.log(`Stages: ${stages.join(', ')}`);
+  console.log(`Output: ${outputDir}`);
+  console.log(`With agent: ${withAgent}`);
+  console.log('');
+
+  // Step 1: Create workspace folder structure
+  console.log('Step 1: Creating workspace folder structure...');
+  scaffoldWorkspace({
+    name: workspaceName,
+    stages,
+    output: outputDir,
+    force: true,
+  });
+
+  // Step 2: Create agent if enabled
+  if (withAgent) {
+    console.log('\nStep 2: Creating invokable agent...');
+    
+    // Generate agent name from workspace name if not provided
+    const agentName = agentNameOption ?? generateAgentName(workspaceName);
+    
+    const agentOptions: AgentOptions = {
+      name: agentName,
+      purpose: `Execute ${workspaceName} workflow`,
+      workspacePath: outputDir,
+    };
+    
+    createAgent(agentOptions);
+    
+    // Step 3: Run agent self-improvement loop
+    console.log('\nStep 3: Running agent self-improvement...');
+    const agentDirName = agentName.startsWith('@') ? agentName.slice(1) : agentName;
+    const agentPath = path.join(outputDir, '.agents', 'skills', agentDirName);
+    
+    const iterationResult = await iterateAgent({
+      agentPath,
+      workspacePath: outputDir,
+      threshold,
+      maxIterations,
+    });
+    
+    // Step 4: Install for detected platform
+    console.log('\nStep 4: Installing for platform...');
+    const platform = detectPlatform();
+    console.log(`Detected platform: ${platform}`);
+    
+    const installer = getPlatformInstaller(platform);
+    installer.install(agentPath, outputDir);
+    
+    console.log('\n=== Workspace Creation Complete ===');
+    console.log(`Workspace: ${outputDir}`);
+    console.log(`Agent: ${agentName}`);
+    console.log(`Score: ${iterationResult.score}/${threshold}`);
+    console.log(`Iterations: ${iterationResult.iterations}`);
+    console.log(`\nTo invoke the agent, use: @${agentName.slice(1)}`);
+  } else {
+    console.log('\n=== Workspace Creation Complete ===');
+    console.log(`Workspace: ${outputDir}`);
+    console.log('(Agent creation disabled with --no-agent)');
+  }
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args.includes('--help')) {
+    showHelp();
+    process.exit(0);
+  }
+
+  // Check for workspace creation
+  if (args.includes('--create-workspace')) {
+    await createWorkspace(args);
+    return;
+  }
+
+  // Check for install targets
+  const agentFlags: AgentTarget[] = ['opencode', 'claude', 'copilot', 'gemini'];
+  const detectedAgent = agentFlags.find((flag) => args.includes(`--${flag}`));
+
+  if (detectedAgent) {
+    const cwd = process.cwd();
+    const projectRoot = detectProjectRoot(cwd);
+
+    if (projectRoot !== cwd) {
+      console.log(`Detected project root: ${projectRoot}`);
+    }
+
+    const templatesDir =
+      process.env.WORKSPACE_MAXXING_TEMPLATES ??
+      path.join(__dirname, '..', 'templates');
+
+    console.log(`Installing workspace-maxxing skill for ${detectedAgent}...`);
+    const result = await installSkill(projectRoot, templatesDir, detectedAgent);
+
+    if (result.success) {
+      console.log(`Skill installed to: ${result.skillPath}`);
+      console.log(`Open a new ${detectedAgent} session and invoke the workspace-maxxing skill to get started.`);
+    } else {
+      console.error(`Installation failed: ${result.error}`);
+      process.exit(1);
+    }
+
+    return;
+  }
+
+  console.error(`Unknown flag: ${args.find((a) => a.startsWith('--'))}`);
+  console.error('Run "npx workspace-maxxing --help" for usage.');
+  process.exit(1);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/src/install.ts

@@ -0,0 +1,105 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export type AgentTarget = 'opencode' | 'claude' | 'copilot' | 'gemini' | undefined;
+
+export interface InstallResult {
+  success: boolean;
+  skillPath: string;
+  error?: string;
+}
+
+const AGENT_PATHS: Record<string, string> = {
+  opencode: '.agents/skills/workspace-maxxing',
+  claude: '.claude/skills',
+  copilot: '.github/copilot-instructions',
+  gemini: '.gemini/skills',
+};
+
+export function getAgentTargetPath(projectRoot: string, agent: AgentTarget): string {
+  const relativePath = AGENT_PATHS[agent ?? 'opencode'];
+  return path.join(projectRoot, relativePath);
+}
+
+/**
+ * Walk up from startDir looking for package.json or .git directory.
+ * Returns the first parent containing a marker, or startDir if none found.
+ */
+export function detectProjectRoot(startDir: string): string {
+  let current = path.resolve(startDir);
+  const root = path.parse(current).root;
+
+  while (current !== root) {
+    const hasPackageJson = fs.existsSync(path.join(current, 'package.json'));
+    const hasGit = fs.existsSync(path.join(current, '.git'));
+
+    if (hasPackageJson || hasGit) {
+      return current;
+    }
+
+    current = path.dirname(current);
+  }
+
+  return startDir;
+}
+
+/**
+ * Recursively copy a directory, overwriting existing files.
+ */
+function copyDirSync(src: string, dest: string): void {
+  if (!fs.existsSync(src)) {
+    throw new Error(`Source directory not found: ${src}`);
+  }
+
+  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()) {
+      copyDirSync(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Install the workspace-maxxing skill into a project.
+ * Copies SKILL.md, .workspace-templates/, and scripts/ to the agent-specific skill directory.
+ */
+export async function installSkill(
+  projectRoot: string,
+  templatesDir: string,
+  agent: AgentTarget = undefined,
+): Promise<InstallResult> {
+  const skillDir = getAgentTargetPath(projectRoot, agent);
+
+  try {
+    // Copy SKILL.md
+    const skillMdSrc = path.join(templatesDir, 'SKILL.md');
+    const skillMdDest = path.join(skillDir, 'SKILL.md');
+    fs.mkdirSync(path.dirname(skillMdDest), { recursive: true });
+    fs.copyFileSync(skillMdSrc, skillMdDest);
+
+    // Copy .workspace-templates/
+    const workspaceTemplatesSrc = path.join(templatesDir, '.workspace-templates');
+    const workspaceTemplatesDest = path.join(skillDir, '.workspace-templates');
+    copyDirSync(workspaceTemplatesSrc, workspaceTemplatesDest);
+
+    // Copy scripts to skill root for direct invocation
+    const scriptsSrc = path.join(templatesDir, '.workspace-templates', 'scripts');
+    if (fs.existsSync(scriptsSrc)) {
+      const scriptsDest = path.join(skillDir, 'scripts');
+      copyDirSync(scriptsSrc, scriptsDest);
+    }
+
+    return { success: true, skillPath: skillDir };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, skillPath: skillDir, error: message };
+  }
+}