workspace-maxxing 0.1.0

package/tests/generate-tests.test.ts

@@ -0,0 +1,101 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { generateTestCases, TestCase } from '../src/scripts/generate-tests';
+
+describe('generate-tests', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'generate-tests-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  function createWorkspaceWithStages(stageNames: string[]): string {
+    const ws = path.join(tempDir, 'workspace');
+    fs.mkdirSync(ws, { recursive: true });
+    fs.writeFileSync(path.join(ws, 'SYSTEM.md'), `# Test\n\n## Folder Map\n\n${stageNames.map((s) => `- \`${s}/\``).join('\n')}\n`);
+    fs.writeFileSync(path.join(ws, 'CONTEXT.md'), `# Router\n\n## Routing Table\n\n${stageNames.map((s) => `- \`${s}/\``).join('\n')}\n`);
+
+    for (const stage of stageNames) {
+      const stageDir = path.join(ws, stage);
+      fs.mkdirSync(stageDir, { recursive: true });
+      fs.writeFileSync(path.join(stageDir, 'CONTEXT.md'), `# ${stage}\n\n## Purpose\nTest stage\n\n## Inputs\nRaw data\n\n## Outputs\nProcessed data\n\n## Dependencies\nNone\n`);
+    }
+
+    return ws;
+  }
+
+  describe('generateTestCases', () => {
+    it('generates test cases for each stage', () => {
+      const ws = createWorkspaceWithStages(['01-input', '02-process', '03-output']);
+      const result = generateTestCases(ws);
+
+      const stages = [...new Set(result.testCases.map((tc) => tc.stage))];
+      expect(stages).toContain('01-input');
+      expect(stages).toContain('02-process');
+      expect(stages).toContain('03-output');
+    });
+
+    it('generates 2-3 test cases per stage', () => {
+      const ws = createWorkspaceWithStages(['01-input', '02-process']);
+      const result = generateTestCases(ws);
+
+      const inputCases = result.testCases.filter((tc) => tc.stage === '01-input');
+      const processCases = result.testCases.filter((tc) => tc.stage === '02-process');
+
+      expect(inputCases.length).toBeGreaterThanOrEqual(2);
+      expect(inputCases.length).toBeLessThanOrEqual(3);
+      expect(processCases.length).toBeGreaterThanOrEqual(2);
+      expect(processCases.length).toBeLessThanOrEqual(3);
+    });
+
+    it('includes sample, edge-case, and empty test types', () => {
+      const ws = createWorkspaceWithStages(['01-input']);
+      const result = generateTestCases(ws);
+
+      const types = result.testCases.map((tc) => tc.type);
+      expect(types).toContain('sample');
+      expect(types).toContain('edge-case');
+      expect(types).toContain('empty');
+    });
+
+    it('returns empty test cases for workspace with no stages', () => {
+      const ws = path.join(tempDir, 'workspace');
+      fs.mkdirSync(ws, { recursive: true });
+      fs.writeFileSync(path.join(ws, 'SYSTEM.md'), '# Test\n');
+      fs.writeFileSync(path.join(ws, 'CONTEXT.md'), '# Router\n');
+
+      const result = generateTestCases(ws);
+
+      expect(result.testCases).toHaveLength(0);
+    });
+
+    it('each test case has required fields', () => {
+      const ws = createWorkspaceWithStages(['01-input']);
+      const result = generateTestCases(ws);
+
+      for (const tc of result.testCases) {
+        expect(tc).toHaveProperty('stage');
+        expect(tc).toHaveProperty('type');
+        expect(tc).toHaveProperty('input');
+        expect(tc).toHaveProperty('expected');
+      }
+    });
+
+    it('writes valid JSON to output file', () => {
+      const ws = createWorkspaceWithStages(['01-input', '02-output']);
+      const outputPath = path.join(tempDir, 'tests.json');
+
+      generateTestCases(ws, outputPath);
+
+      const content = fs.readFileSync(outputPath, 'utf-8');
+      const parsed = JSON.parse(content);
+      expect(parsed).toHaveProperty('testCases');
+      expect(Array.isArray(parsed.testCases)).toBe(true);
+    });
+  });
+});

package/tests/install-tool.test.ts

@@ -0,0 +1,141 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { installTool, InstallToolOptions } from '../src/scripts/install-tool';
+
+jest.mock('child_process', () => ({
+  execSync: jest.fn(),
+}));
+
+const { execSync } = require('child_process');
+
+describe('install-tool', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'install-tool-test-'));
+    const metaDir = path.join(tempDir, '00-meta');
+    fs.mkdirSync(metaDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(metaDir, 'tools.md'),
+      '# Tool Inventory\n\n## Installed Tools\n\n| Tool | Version | Manager | Installed |\n|------|---------|---------|-----------|\n| — | — | — | — |\n',
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    jest.clearAllMocks();
+  });
+
+  describe('installTool', () => {
+    it('runs correct npm install command', () => {
+      (execSync as jest.Mock).mockReturnValue('');
+
+      const options: InstallToolOptions = {
+        tool: 'pdf-lib',
+        manager: 'npm',
+        workspace: tempDir,
+      };
+
+      installTool(options);
+
+      expect(execSync).toHaveBeenCalledWith(
+        'npm install pdf-lib',
+        expect.objectContaining({ cwd: tempDir, stdio: 'inherit' }),
+      );
+    });
+
+    it('runs correct pip install command', () => {
+      (execSync as jest.Mock).mockReturnValue('');
+
+      const options: InstallToolOptions = {
+        tool: 'requests',
+        manager: 'pip',
+        workspace: tempDir,
+      };
+
+      installTool(options);
+
+      expect(execSync).toHaveBeenCalledWith(
+        'pip install requests',
+        expect.objectContaining({ cwd: tempDir, stdio: 'inherit' }),
+      );
+    });
+
+    it('runs correct npx install command', () => {
+      (execSync as jest.Mock).mockReturnValue('');
+
+      const options: InstallToolOptions = {
+        tool: 'create-next-app',
+        manager: 'npx',
+        workspace: tempDir,
+      };
+
+      installTool(options);
+
+      expect(execSync).toHaveBeenCalledWith(
+        'npx create-next-app',
+        expect.objectContaining({ cwd: tempDir, stdio: 'inherit' }),
+      );
+    });
+
+    it('runs correct brew install command', () => {
+      (execSync as jest.Mock).mockReturnValue('');
+
+      const options: InstallToolOptions = {
+        tool: 'ffmpeg',
+        manager: 'brew',
+        workspace: tempDir,
+      };
+
+      installTool(options);
+
+      expect(execSync).toHaveBeenCalledWith(
+        'brew install ffmpeg',
+        expect.objectContaining({ cwd: tempDir, stdio: 'inherit' }),
+      );
+    });
+
+    it('updates tools.md with installed tool', () => {
+      (execSync as jest.Mock).mockReturnValue('');
+
+      const options: InstallToolOptions = {
+        tool: 'pdf-lib',
+        manager: 'npm',
+        workspace: tempDir,
+      };
+
+      installTool(options);
+
+      const toolsMd = fs.readFileSync(path.join(tempDir, '00-meta', 'tools.md'), 'utf-8');
+      expect(toolsMd).toContain('pdf-lib');
+      expect(toolsMd).toContain('npm');
+    });
+
+    it('throws if install command fails', () => {
+      (execSync as jest.Mock).mockImplementation(() => {
+        const err = new Error('Command failed');
+        (err as any).status = 1;
+        throw err;
+      });
+
+      const options: InstallToolOptions = {
+        tool: 'nonexistent-package',
+        manager: 'npm',
+        workspace: tempDir,
+      };
+
+      expect(() => installTool(options)).toThrow('Command failed');
+    });
+
+    it('throws for unsupported manager', () => {
+      const options: InstallToolOptions = {
+        tool: 'something',
+        manager: 'unknown' as any,
+        workspace: tempDir,
+      };
+
+      expect(() => installTool(options)).toThrow('Unsupported package manager');
+    });
+  });
+});

package/tests/install.test.ts

@@ -0,0 +1,144 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { installSkill, detectProjectRoot, getAgentTargetPath } from '../src/install';
+
+describe('install', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'workspace-maxxing-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('detectProjectRoot', () => {
+    it('returns the directory containing package.json', () => {
+      const projectDir = path.join(tempDir, 'my-project');
+      fs.mkdirSync(projectDir, { recursive: true });
+      fs.writeFileSync(path.join(projectDir, 'package.json'), '{}');
+
+      const result = detectProjectRoot(projectDir);
+      expect(result).toBe(projectDir);
+    });
+
+    it('returns the directory containing .git', () => {
+      const projectDir = path.join(tempDir, 'my-project');
+      fs.mkdirSync(path.join(projectDir, '.git'), { recursive: true });
+
+      const result = detectProjectRoot(projectDir);
+      expect(result).toBe(projectDir);
+    });
+
+    it('returns current directory if no marker found', () => {
+      const result = detectProjectRoot(tempDir);
+      expect(result).toBe(tempDir);
+    });
+
+    it('walks up parent directories to find marker', () => {
+      const projectDir = path.join(tempDir, 'my-project');
+      const nestedDir = path.join(projectDir, 'src', 'utils');
+      fs.mkdirSync(nestedDir, { recursive: true });
+      fs.writeFileSync(path.join(projectDir, 'package.json'), '{}');
+
+      const result = detectProjectRoot(nestedDir);
+      expect(result).toBe(projectDir);
+    });
+  });
+
+  describe('installSkill', () => {
+    it('creates the skill directory structure', async () => {
+      const projectDir = path.join(tempDir, 'my-project');
+      fs.mkdirSync(projectDir, { recursive: true });
+      fs.writeFileSync(path.join(projectDir, 'package.json'), '{}');
+
+      const templatesDir = path.join(__dirname, '..', 'templates');
+      const result = await installSkill(projectDir, templatesDir);
+
+      expect(result.success).toBe(true);
+      expect(fs.existsSync(path.join(projectDir, '.agents', 'skills', 'workspace-maxxing'))).toBe(true);
+    });
+
+    it('copies SKILL.md to the skill directory', async () => {
+      const projectDir = path.join(tempDir, 'my-project');
+      fs.mkdirSync(projectDir, { recursive: true });
+      fs.writeFileSync(path.join(projectDir, 'package.json'), '{}');
+
+      const templatesDir = path.join(__dirname, '..', 'templates');
+      await installSkill(projectDir, templatesDir);
+
+      const skillPath = path.join(projectDir, '.agents', 'skills', 'workspace-maxxing', 'SKILL.md');
+      expect(fs.existsSync(skillPath)).toBe(true);
+    });
+
+    it('copies workspace templates', async () => {
+      const projectDir = path.join(tempDir, 'my-project');
+      fs.mkdirSync(projectDir, { recursive: true });
+      fs.writeFileSync(path.join(projectDir, 'package.json'), '{}');
+
+      const templatesDir = path.join(__dirname, '..', 'templates');
+      await installSkill(projectDir, templatesDir);
+
+      const systemMd = path.join(projectDir, '.agents', 'skills', 'workspace-maxxing', '.workspace-templates', 'SYSTEM.md');
+      const contextMd = path.join(projectDir, '.agents', 'skills', 'workspace-maxxing', '.workspace-templates', 'CONTEXT.md');
+      expect(fs.existsSync(systemMd)).toBe(true);
+      expect(fs.existsSync(contextMd)).toBe(true);
+    });
+
+    it('is idempotent — running twice produces same result', async () => {
+      const projectDir = path.join(tempDir, 'my-project');
+      fs.mkdirSync(projectDir, { recursive: true });
+      fs.writeFileSync(path.join(projectDir, 'package.json'), '{}');
+
+      const templatesDir = path.join(__dirname, '..', 'templates');
+      await installSkill(projectDir, templatesDir);
+      const result2 = await installSkill(projectDir, templatesDir);
+
+      expect(result2.success).toBe(true);
+      const skillPath = path.join(projectDir, '.agents', 'skills', 'workspace-maxxing', 'SKILL.md');
+      expect(fs.existsSync(skillPath)).toBe(true);
+    });
+  });
+
+  describe('getAgentTargetPath', () => {
+    it('returns default path for no agent', () => {
+      const result = getAgentTargetPath('/project-root', undefined);
+      expect(result).toBe(path.join('/project-root', '.agents', 'skills', 'workspace-maxxing'));
+    });
+
+    it('returns opencode path for --opencode flag', () => {
+      const result = getAgentTargetPath('/project-root', 'opencode');
+      expect(result).toBe(path.join('/project-root', '.agents', 'skills', 'workspace-maxxing'));
+    });
+
+    it('returns claude path for --claude flag', () => {
+      const result = getAgentTargetPath('/project-root', 'claude');
+      expect(result).toBe(path.join('/project-root', '.claude', 'skills'));
+    });
+
+    it('returns copilot path for --copilot flag', () => {
+      const result = getAgentTargetPath('/project-root', 'copilot');
+      expect(result).toBe(path.join('/project-root', '.github', 'copilot-instructions'));
+    });
+
+    it('returns gemini path for --gemini flag', () => {
+      const result = getAgentTargetPath('/project-root', 'gemini');
+      expect(result).toBe(path.join('/project-root', '.gemini', 'skills'));
+    });
+
+    it('installs to claude path when agent is claude', async () => {
+      const projectDir = path.join(tempDir, 'my-project');
+      fs.mkdirSync(projectDir, { recursive: true });
+      fs.writeFileSync(path.join(projectDir, 'package.json'), '{}');
+
+      const templatesDir = path.join(__dirname, '..', 'templates');
+      const result = await installSkill(projectDir, templatesDir, 'claude');
+
+      expect(result.success).toBe(true);
+      expect(result.skillPath).toContain('.claude');
+      expect(fs.existsSync(path.join(projectDir, '.claude', 'skills', 'SKILL.md'))).toBe(true);
+    });
+  });
+});