workspace-maxxing 0.1.0

package/templates/.workspace-templates/scripts/generate-tests.ts

@@ -0,0 +1,158 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface TestCase {
+  stage: string;
+  type: 'sample' | 'edge-case' | 'empty';
+  input: string;
+  expected: string;
+}
+
+export interface TestCasesOutput {
+  testCases: TestCase[];
+}
+
+export function generateTestCases(
+  workspacePath: string,
+  outputPath?: string,
+): TestCasesOutput {
+  const ws = path.resolve(workspacePath);
+  const testCases: TestCase[] = [];
+  const workspaceDomain = detectWorkspaceDomain(ws);
+
+  const stageFolders = getNumberedFolders(ws);
+
+  if (stageFolders.length === 0) {
+    console.warn('Warning: No numbered stage folders found in workspace');
+  }
+
+  for (const stage of stageFolders) {
+    const contextPath = path.join(ws, stage, 'CONTEXT.md');
+    let purpose = '';
+    if (fs.existsSync(contextPath)) {
+      const content = fs.readFileSync(contextPath, 'utf-8');
+      const purposeMatch = content.match(/## Purpose\n([\s\S]*?)(?=##|$)/i);
+      if (purposeMatch) {
+        purpose = purposeMatch[1].trim();
+      }
+    }
+
+    testCases.push({
+      stage,
+      type: 'sample',
+      input: generateSampleInput(stage, purpose, workspaceDomain),
+      expected: `Stage should fulfill its purpose: ${purpose || 'handle stage-specific processing'}`,
+    });
+
+    testCases.push({
+      stage,
+      type: 'edge-case',
+      input: generateEdgeCaseInput(stage, workspaceDomain),
+      expected: `Stage should handle edge case gracefully`,
+    });
+
+    testCases.push({
+      stage,
+      type: 'empty',
+      input: '',
+      expected: `Stage should handle empty input gracefully`,
+    });
+  }
+
+  const result: TestCasesOutput = { testCases };
+
+  if (outputPath) {
+    fs.writeFileSync(outputPath, JSON.stringify(result, null, 2));
+    console.log(`Test cases written to: ${outputPath}`);
+  }
+
+  return result;
+}
+
+function generateSampleInput(stage: string, purpose: string, domain: string): string {
+  if (domain === 'sports-prediction') {
+    const sportsSamples: Record<string, string> = {
+      '01-input': 'Barcelona vs Real Madrid next match prediction request with team form and injury notes',
+      '02-process': 'UCL finals winner prediction using recent xG, head-to-head history, and squad availability',
+      '03-output': 'Liverpool vs Arsenal game prediction with confidence score and rationale summary',
+    };
+
+    return sportsSamples[stage] || `Sports match outcome prediction scenario for ${stage}`;
+  }
+
+  const samples: Record<string, string> = {
+    '01-input': 'A sample input document with valid data for processing',
+    '02-process': 'Processed data from the input stage ready for transformation',
+    '03-output': 'Final processed data ready for report generation',
+  };
+  return samples[stage] || `Sample data for ${stage}`;
+}
+
+function generateEdgeCaseInput(stage: string, domain: string): string {
+  if (domain === 'sports-prediction') {
+    const sportsEdgeCases: Record<string, string> = {
+      '01-input': 'Barcelona vs Real Madrid request missing kickoff date and missing expected league context',
+      '02-process': 'UCL finals winner scenario with conflicting bookmaker odds and incomplete player availability data',
+      '03-output': 'Liverpool vs Arsenal prediction where confidence exceeds bounds and explanation is inconsistent',
+    };
+
+    return sportsEdgeCases[stage] || `Sports prediction edge case data for ${stage}`;
+  }
+
+  const edgeCases: Record<string, string> = {
+    '01-input': 'Input with special characters: <>&"\' and very long text that exceeds normal length expectations',
+    '02-process': 'Data with missing fields and inconsistent formatting',
+    '03-output': 'Conflicting output requirements from upstream stages',
+  };
+  return edgeCases[stage] || `Edge case data for ${stage}`;
+}
+
+function detectWorkspaceDomain(workspacePath: string): string {
+  const filesToScan = ['SYSTEM.md', 'CONTEXT.md'];
+  const textChunks: string[] = [];
+
+  for (const fileName of filesToScan) {
+    const filePath = path.join(workspacePath, fileName);
+    if (fs.existsSync(filePath)) {
+      textChunks.push(fs.readFileSync(filePath, 'utf-8'));
+    }
+  }
+
+  const stageFolders = getNumberedFolders(workspacePath);
+  for (const stage of stageFolders) {
+    const contextPath = path.join(workspacePath, stage, 'CONTEXT.md');
+    if (fs.existsSync(contextPath)) {
+      textChunks.push(fs.readFileSync(contextPath, 'utf-8'));
+    }
+  }
+
+  const corpus = textChunks.join('\n').toLowerCase();
+  const sportsPredictionMatch = /(football|soccer|ucl|champions league|match prediction|sports prediction|game prediction)/i.test(corpus);
+
+  return sportsPredictionMatch ? 'sports-prediction' : 'generic';
+}
+
+function getNumberedFolders(workspacePath: string): string[] {
+  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);
+}
+
+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');
+  const output = parseArg('--output');
+
+  if (!workspace) {
+    console.error('Usage: node generate-tests.ts --workspace <path> [--output <path>]');
+    process.exit(1);
+  }
+
+  generateTestCases(workspace, output);
+}

package/templates/.workspace-templates/scripts/install-tool.ts

@@ -0,0 +1,82 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+
+export type PackageManager = 'npm' | 'pip' | 'npx' | 'brew';
+
+export interface InstallToolOptions {
+  tool: string;
+  manager: PackageManager;
+  workspace: string;
+}
+
+export function installTool(options: InstallToolOptions): void {
+  const { tool, manager, workspace } = options;
+  const ws = path.resolve(workspace);
+
+  const validManagers: PackageManager[] = ['npm', 'pip', 'npx', 'brew'];
+  if (!validManagers.includes(manager)) {
+    throw new Error(`Unsupported package manager: ${manager}. Supported: ${validManagers.join(', ')}`);
+  }
+
+  const command = manager === 'npx' ? `npx ${tool}` : `${manager} install ${tool}`;
+
+  console.log(`Installing ${tool} via ${manager}...`);
+  try {
+    execSync(command, { cwd: ws, stdio: 'inherit' });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to install ${tool}: ${message}`);
+  }
+
+  updateToolsMd(ws, tool, manager);
+
+  console.log(`✓ ${tool} installed and added to tool inventory`);
+}
+
+function updateToolsMd(workspace: string, tool: string, manager: string): void {
+  const toolsMdPath = path.join(workspace, '00-meta', 'tools.md');
+
+  if (!fs.existsSync(toolsMdPath)) {
+    throw new Error(`tools.md not found at: ${toolsMdPath}`);
+  }
+
+  const content = fs.readFileSync(toolsMdPath, 'utf-8');
+  const now = new Date().toISOString().split('T')[0];
+
+  const placeholderRow = '| — | — | — | — |';
+  const newRow = `| ${tool} | latest | ${manager} | ${now} |`;
+
+  let updated: string;
+  if (content.includes(placeholderRow)) {
+    updated = content.replace(placeholderRow, `${placeholderRow}\n${newRow}`);
+  } else {
+    const pendingIdx = content.indexOf('## Pending Tools');
+    if (pendingIdx !== -1) {
+      updated = content.slice(0, pendingIdx) + newRow + '\n\n' + content.slice(pendingIdx);
+    } else {
+      updated = content + '\n' + newRow + '\n';
+    }
+  }
+
+  fs.writeFileSync(toolsMdPath, updated);
+}
+
+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 tool = parseArg('--tool');
+  const manager = parseArg('--manager') as PackageManager;
+  const workspace = parseArg('--workspace');
+
+  if (!tool || !manager || !workspace) {
+    console.error('Usage: node install-tool.ts --tool <name> --manager <npm|pip|npx|brew> --workspace <path>');
+    process.exit(1);
+  }
+
+  installTool({ tool, manager, workspace });
+}

package/templates/.workspace-templates/scripts/iterate.ts

@@ -0,0 +1,265 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { validateWorkspace } from './validate';
+
+export interface IterateOptions {
+  maxRetries?: number;
+}
+
+export interface ValidatePassResult {
+  status: 'passed' | 'failed' | 'escalated';
+  retries: number;
+  failures?: string[];
+}
+
+export interface ScorePassResult {
+  score: number;
+  improvements: string[];
+}
+
+export interface ChecklistResult {
+  items: number;
+  passed: number;
+  failed: number;
+  details: { name: string; passed: boolean }[];
+}
+
+export interface IterateResult {
+  passes: {
+    validate: ValidatePassResult;
+    score: ScorePassResult;
+    checklist: ChecklistResult;
+  };
+  escalate: boolean;
+}
+
+export interface ScoreBreakdown {
+  system: number;
+  context: number;
+  stages: number;
+  tools: number;
+  total: number;
+  improvements: string[];
+}
+
+export function iterateWorkspace(
+  workspacePath: string,
+  options: IterateOptions = {},
+): IterateResult {
+  const { maxRetries = 3 } = options;
+  const ws = path.resolve(workspacePath);
+
+  const validateResult = runValidatePass(ws, maxRetries);
+  const scoreResult = runScorePass(ws);
+  const checklistResult = runChecklist(ws);
+
+  const result: IterateResult = {
+    passes: {
+      validate: validateResult,
+      score: scoreResult,
+      checklist: checklistResult,
+    },
+    escalate: validateResult.status === 'escalated',
+  };
+
+  console.log(JSON.stringify(result, null, 2));
+
+  return result;
+}
+
+function runValidatePass(ws: string, maxRetries: number): ValidatePassResult {
+  let retries = 0;
+
+  for (let i = 0; i < maxRetries; i++) {
+    const result = validateWorkspace(ws);
+
+    if (result.passed) {
+      return { status: 'passed', retries: i };
+    }
+
+    retries = i + 1;
+  }
+
+  const lastResult = validateWorkspace(ws);
+  const failures = lastResult.checks.filter((c) => !c.passed).map((c) => `${c.name}: ${c.message}`);
+
+  return {
+    status: 'escalated',
+    retries,
+    failures,
+  };
+}
+
+function runScorePass(ws: string): ScorePassResult {
+  const score = scoreWorkspace(ws);
+  return {
+    score: score.total,
+    improvements: score.improvements,
+  };
+}
+
+export function scoreWorkspace(workspacePath: string): ScoreBreakdown {
+  const ws = path.resolve(workspacePath);
+  const improvements: string[] = [];
+  let system = 0;
+  let context = 0;
+  let stages = 0;
+  let tools = 0;
+
+  const systemMdPath = path.join(ws, 'SYSTEM.md');
+  if (fs.existsSync(systemMdPath)) {
+    const content = fs.readFileSync(systemMdPath, 'utf-8');
+    if (content.toLowerCase().includes('## role') || content.toLowerCase().includes('role')) system += 7;
+    else improvements.push('SYSTEM.md missing Role section');
+    if (content.toLowerCase().includes('folder map')) system += 7;
+    else improvements.push('SYSTEM.md missing Folder Map');
+    if (content.toLowerCase().includes('## rules') || content.toLowerCase().includes('rule')) system += 6;
+    else improvements.push('SYSTEM.md missing Rules section');
+  } else {
+    improvements.push('SYSTEM.md missing entirely');
+  }
+
+  const contextMdPath = path.join(ws, 'CONTEXT.md');
+  if (fs.existsSync(contextMdPath)) {
+    const content = fs.readFileSync(contextMdPath, 'utf-8');
+    if (content.toLowerCase().includes('routing table')) context += 10;
+    else improvements.push('CONTEXT.md missing Routing Table');
+    const numberedFolders = getNumberedFolders(ws);
+    const allReferenced = numberedFolders.every((f) => content.includes(f));
+    if (allReferenced && numberedFolders.length > 0) context += 10;
+    else if (numberedFolders.length > 0) improvements.push('CONTEXT.md does not reference all stages');
+  } else {
+    improvements.push('CONTEXT.md missing entirely');
+  }
+
+  const stageFolders = getNumberedFolders(ws);
+  let stageScore = 0;
+  for (const folder of stageFolders) {
+    const stageContextPath = path.join(ws, folder, 'CONTEXT.md');
+    let folderScore = 0;
+    if (fs.existsSync(stageContextPath)) {
+      const content = fs.readFileSync(stageContextPath, 'utf-8');
+      if (content.toLowerCase().includes('purpose') || content.toLowerCase().includes('## purpose')) folderScore += 4;
+      else improvements.push(`${folder}/CONTEXT.md missing Purpose`);
+      if (content.toLowerCase().includes('input')) folderScore += 4;
+      else improvements.push(`${folder}/CONTEXT.md missing Inputs`);
+      if (content.toLowerCase().includes('output')) folderScore += 4;
+      else improvements.push(`${folder}/CONTEXT.md missing Outputs`);
+      if (content.toLowerCase().includes('dependenc')) folderScore += 3;
+      else improvements.push(`${folder}/CONTEXT.md missing Dependencies`);
+    } else {
+      improvements.push(`${folder}/CONTEXT.md missing`);
+    }
+    stageScore += folderScore;
+  }
+  stages = Math.min(stageScore, 45);
+
+  const toolsMdPath = path.join(ws, '00-meta', 'tools.md');
+  if (fs.existsSync(toolsMdPath)) {
+    const content = fs.readFileSync(toolsMdPath, 'utf-8');
+    if (content.trim().length > 20) tools += 15;
+    else {
+      tools += 5;
+      improvements.push('tools.md exists but has minimal content');
+    }
+  } else {
+    improvements.push('tools.md missing');
+  }
+
+  return {
+    system,
+    context,
+    stages,
+    tools,
+    total: system + context + stages + tools,
+    improvements,
+  };
+}
+
+export function runChecklist(workspacePath: string): ChecklistResult {
+  const ws = path.resolve(workspacePath);
+  const details: { name: string; passed: boolean }[] = [];
+
+  const stageFolders = getNumberedFolders(ws);
+
+  for (const folder of stageFolders) {
+    const contextPath = path.join(ws, folder, 'CONTEXT.md');
+    if (fs.existsSync(contextPath)) {
+      const content = fs.readFileSync(contextPath, 'utf-8');
+      details.push({
+        name: `${folder} has inputs defined`,
+        passed: content.toLowerCase().includes('input'),
+      });
+      details.push({
+        name: `${folder} has outputs defined`,
+        passed: content.toLowerCase().includes('output'),
+      });
+      details.push({
+        name: `${folder} has dependencies defined`,
+        passed: content.toLowerCase().includes('dependenc'),
+      });
+    } else {
+      details.push({ name: `${folder} has CONTEXT.md`, passed: false });
+      details.push({ name: `${folder} has inputs defined`, passed: false });
+      details.push({ name: `${folder} has outputs defined`, passed: false });
+      details.push({ name: `${folder} has dependencies defined`, passed: false });
+    }
+  }
+
+  const contextMdPath = path.join(ws, 'CONTEXT.md');
+  if (fs.existsSync(contextMdPath)) {
+    const content = fs.readFileSync(contextMdPath, 'utf-8');
+    const allReferenced = stageFolders.every((f) => content.includes(f));
+    details.push({
+      name: 'Routing table references all numbered folders',
+      passed: allReferenced,
+    });
+  } else {
+    details.push({
+      name: 'Routing table references all numbered folders',
+      passed: false,
+    });
+  }
+
+  const readmePath = path.join(ws, 'README.md');
+  details.push({
+    name: 'README.md exists and has usage instructions',
+    passed: fs.existsSync(readmePath) && fs.readFileSync(readmePath, 'utf-8').trim().length > 0,
+  });
+
+  const passed = details.filter((d) => d.passed).length;
+  const failed = details.filter((d) => !d.passed).length;
+
+  return {
+    items: details.length,
+    passed,
+    failed,
+    details,
+  };
+}
+
+function getNumberedFolders(workspacePath: string): string[] {
+  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);
+}
+
+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');
+  const maxRetriesStr = parseArg('--max-retries');
+  const maxRetries = maxRetriesStr ? parseInt(maxRetriesStr, 10) : 3;
+
+  if (!workspace) {
+    console.error('Usage: node iterate.ts --workspace <path> [--max-retries <n>]');
+    process.exit(1);
+  }
+
+  iterateWorkspace(workspace, { maxRetries });
+}