@nicnocquee/dataqueue 1.33.0 → 1.35.0-beta.20260224075710

package/src/install-rules-command.test.ts

@@ -0,0 +1,218 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import {
+  runInstallRules,
+  upsertMarkedSection,
+  InstallRulesDeps,
+} from './install-rules-command.js';
+
+describe('upsertMarkedSection', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('creates file with markers when file does not exist', () => {
+    // Setup
+    const deps = {
+      existsSync: vi.fn(() => false),
+      readFileSync: vi.fn(),
+      writeFileSync: vi.fn(),
+    };
+
+    // Act
+    upsertMarkedSection('/path/file.md', 'content here', deps);
+
+    // Assert
+    expect(deps.writeFileSync).toHaveBeenCalledWith(
+      '/path/file.md',
+      expect.stringContaining('<!-- DATAQUEUE RULES START -->'),
+    );
+    expect(deps.writeFileSync).toHaveBeenCalledWith(
+      '/path/file.md',
+      expect.stringContaining('content here'),
+    );
+    expect(deps.writeFileSync).toHaveBeenCalledWith(
+      '/path/file.md',
+      expect.stringContaining('<!-- DATAQUEUE RULES END -->'),
+    );
+  });
+
+  it('replaces existing marked section', () => {
+    // Setup
+    const existing =
+      'before\n<!-- DATAQUEUE RULES START -->\nold content\n<!-- DATAQUEUE RULES END -->\nafter';
+    const deps = {
+      existsSync: vi.fn(() => true),
+      readFileSync: vi.fn(() => existing),
+      writeFileSync: vi.fn(),
+    };
+
+    // Act
+    upsertMarkedSection('/path/file.md', 'new content', deps);
+
+    // Assert
+    const written = deps.writeFileSync.mock.calls[0][1] as string;
+    expect(written).toContain('before\n');
+    expect(written).toContain('new content');
+    expect(written).not.toContain('old content');
+    expect(written).toContain('\nafter');
+  });
+
+  it('appends to file when no markers exist', () => {
+    // Setup
+    const deps = {
+      existsSync: vi.fn(() => true),
+      readFileSync: vi.fn(() => '# Existing content'),
+      writeFileSync: vi.fn(),
+    };
+
+    // Act
+    upsertMarkedSection('/path/file.md', 'new content', deps);
+
+    // Assert
+    const written = deps.writeFileSync.mock.calls[0][1] as string;
+    expect(written).toContain('# Existing content');
+    expect(written).toContain('new content');
+  });
+});
+
+describe('runInstallRules', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  function makeDeps(
+    overrides: Partial<InstallRulesDeps> = {},
+  ): InstallRulesDeps {
+    return {
+      log: vi.fn(),
+      error: vi.fn(),
+      exit: vi.fn(),
+      cwd: '/project',
+      readFileSync: vi.fn(() => '# Rule content'),
+      writeFileSync: vi.fn(),
+      appendFileSync: vi.fn(),
+      mkdirSync: vi.fn(),
+      existsSync: vi.fn(() => false),
+      rulesSourceDir: '/pkg/ai/rules',
+      ...overrides,
+    };
+  }
+
+  it('installs rules for Cursor (option 1)', async () => {
+    // Setup
+    const deps = makeDeps({ selectedClient: '1' });
+
+    // Act
+    await runInstallRules(deps);
+
+    // Assert
+    expect(deps.mkdirSync).toHaveBeenCalledWith('/project/.cursor/rules', {
+      recursive: true,
+    });
+    expect(deps.writeFileSync).toHaveBeenCalledWith(
+      expect.stringContaining('.cursor/rules/dataqueue-basic.mdc'),
+      expect.any(String),
+    );
+    expect(deps.writeFileSync).toHaveBeenCalledWith(
+      expect.stringContaining('.cursor/rules/dataqueue-advanced.mdc'),
+      expect.any(String),
+    );
+    expect(deps.writeFileSync).toHaveBeenCalledWith(
+      expect.stringContaining('.cursor/rules/dataqueue-react-dashboard.mdc'),
+      expect.any(String),
+    );
+  });
+
+  it('installs rules for Claude Code (option 2)', async () => {
+    // Setup
+    const deps = makeDeps({ selectedClient: '2' });
+
+    // Act
+    await runInstallRules(deps);
+
+    // Assert
+    expect(deps.writeFileSync).toHaveBeenCalledWith(
+      '/project/CLAUDE.md',
+      expect.stringContaining('<!-- DATAQUEUE RULES START -->'),
+    );
+  });
+
+  it('installs rules for AGENTS.md (option 3)', async () => {
+    // Setup
+    const deps = makeDeps({ selectedClient: '3' });
+
+    // Act
+    await runInstallRules(deps);
+
+    // Assert
+    expect(deps.writeFileSync).toHaveBeenCalledWith(
+      '/project/AGENTS.md',
+      expect.stringContaining('<!-- DATAQUEUE RULES START -->'),
+    );
+  });
+
+  it('installs rules for GitHub Copilot (option 4)', async () => {
+    // Setup
+    const deps = makeDeps({ selectedClient: '4' });
+
+    // Act
+    await runInstallRules(deps);
+
+    // Assert
+    expect(deps.mkdirSync).toHaveBeenCalledWith('/project/.github', {
+      recursive: true,
+    });
+    expect(deps.writeFileSync).toHaveBeenCalledWith(
+      '/project/.github/copilot-instructions.md',
+      expect.stringContaining('<!-- DATAQUEUE RULES START -->'),
+    );
+  });
+
+  it('installs rules for Windsurf (option 5)', async () => {
+    // Setup
+    const deps = makeDeps({ selectedClient: '5' });
+
+    // Act
+    await runInstallRules(deps);
+
+    // Assert
+    expect(deps.writeFileSync).toHaveBeenCalledWith(
+      '/project/CONVENTIONS.md',
+      expect.stringContaining('<!-- DATAQUEUE RULES START -->'),
+    );
+  });
+
+  it('exits with error for invalid choice', async () => {
+    // Setup
+    const deps = makeDeps({ selectedClient: '99' });
+
+    // Act
+    await runInstallRules(deps);
+
+    // Assert
+    expect(deps.error).toHaveBeenCalledWith(
+      expect.stringContaining('Invalid choice'),
+    );
+    expect(deps.exit).toHaveBeenCalledWith(1);
+  });
+
+  it('handles install errors', async () => {
+    // Setup
+    const deps = makeDeps({
+      selectedClient: '1',
+      readFileSync: vi.fn(() => {
+        throw new Error('file not found');
+      }),
+    });
+
+    // Act
+    await runInstallRules(deps);
+
+    // Assert
+    expect(deps.error).toHaveBeenCalledWith(
+      'Failed to install rules:',
+      expect.any(Error),
+    );
+    expect(deps.exit).toHaveBeenCalledWith(1);
+  });
+});

package/src/install-rules-command.ts

@@ -0,0 +1,233 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import readline from 'readline';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export interface InstallRulesDeps {
+  log?: (...args: unknown[]) => void;
+  error?: (...args: unknown[]) => void;
+  exit?: (code: number) => void;
+  cwd?: string;
+  readFileSync?: (p: string, enc: BufferEncoding) => string;
+  writeFileSync?: (p: string, data: string) => void;
+  appendFileSync?: (p: string, data: string) => void;
+  mkdirSync?: (p: string, opts?: fs.MakeDirectoryOptions) => void;
+  existsSync?: (p: string) => boolean;
+  rulesSourceDir?: string;
+  /** Override for selecting the client (skips interactive prompt). */
+  selectedClient?: string;
+}
+
+const RULE_FILES = ['basic.md', 'advanced.md', 'react-dashboard.md'];
+
+interface ClientConfig {
+  label: string;
+  install: (
+    deps: Required<
+      Pick<
+        InstallRulesDeps,
+        | 'cwd'
+        | 'readFileSync'
+        | 'writeFileSync'
+        | 'appendFileSync'
+        | 'mkdirSync'
+        | 'existsSync'
+        | 'log'
+        | 'rulesSourceDir'
+      >
+    >,
+  ) => void;
+}
+
+const MARKER_START = '<!-- DATAQUEUE RULES START -->';
+const MARKER_END = '<!-- DATAQUEUE RULES END -->';
+
+/**
+ * Appends or replaces a marked section in a file.
+ *
+ * @param filePath - Path to the file to update.
+ * @param content - Content to insert between markers.
+ * @param deps - Injectable file system functions.
+ */
+export function upsertMarkedSection(
+  filePath: string,
+  content: string,
+  deps: {
+    readFileSync: (p: string, enc: BufferEncoding) => string;
+    writeFileSync: (p: string, data: string) => void;
+    existsSync: (p: string) => boolean;
+  },
+): void {
+  const block = `${MARKER_START}\n${content}\n${MARKER_END}`;
+
+  if (!deps.existsSync(filePath)) {
+    deps.writeFileSync(filePath, block + '\n');
+    return;
+  }
+
+  const existing = deps.readFileSync(filePath, 'utf-8');
+  const startIdx = existing.indexOf(MARKER_START);
+  const endIdx = existing.indexOf(MARKER_END);
+
+  if (startIdx !== -1 && endIdx !== -1) {
+    const before = existing.slice(0, startIdx);
+    const after = existing.slice(endIdx + MARKER_END.length);
+    deps.writeFileSync(filePath, before + block + after);
+  } else {
+    deps.writeFileSync(filePath, existing.trimEnd() + '\n\n' + block + '\n');
+  }
+}
+
+function getAllRulesContent(
+  rulesSourceDir: string,
+  readFileSync: (p: string, enc: BufferEncoding) => string,
+): string {
+  return RULE_FILES.map((f) =>
+    readFileSync(path.join(rulesSourceDir, f), 'utf-8'),
+  ).join('\n\n');
+}
+
+const CLIENTS: Record<string, ClientConfig> = {
+  '1': {
+    label: 'Cursor',
+    install: (deps) => {
+      const rulesDir = path.join(deps.cwd, '.cursor', 'rules');
+      deps.mkdirSync(rulesDir, { recursive: true });
+
+      for (const file of RULE_FILES) {
+        const src = deps.readFileSync(
+          path.join(deps.rulesSourceDir, file),
+          'utf-8',
+        );
+        const destName = `dataqueue-${file.replace(/\.md$/, '.mdc')}`;
+        deps.writeFileSync(path.join(rulesDir, destName), src);
+        deps.log(`  ✓ .cursor/rules/${destName}`);
+      }
+    },
+  },
+  '2': {
+    label: 'Claude Code',
+    install: (deps) => {
+      const content = getAllRulesContent(
+        deps.rulesSourceDir,
+        deps.readFileSync,
+      );
+      const filePath = path.join(deps.cwd, 'CLAUDE.md');
+      upsertMarkedSection(filePath, content, deps);
+      deps.log(`  ✓ CLAUDE.md`);
+    },
+  },
+  '3': {
+    label: 'AGENTS.md (Codex, Jules, OpenCode)',
+    install: (deps) => {
+      const content = getAllRulesContent(
+        deps.rulesSourceDir,
+        deps.readFileSync,
+      );
+      const filePath = path.join(deps.cwd, 'AGENTS.md');
+      upsertMarkedSection(filePath, content, deps);
+      deps.log(`  ✓ AGENTS.md`);
+    },
+  },
+  '4': {
+    label: 'GitHub Copilot',
+    install: (deps) => {
+      const content = getAllRulesContent(
+        deps.rulesSourceDir,
+        deps.readFileSync,
+      );
+      deps.mkdirSync(path.join(deps.cwd, '.github'), { recursive: true });
+      const filePath = path.join(
+        deps.cwd,
+        '.github',
+        'copilot-instructions.md',
+      );
+      upsertMarkedSection(filePath, content, deps);
+      deps.log(`  ✓ .github/copilot-instructions.md`);
+    },
+  },
+  '5': {
+    label: 'Windsurf',
+    install: (deps) => {
+      const content = getAllRulesContent(
+        deps.rulesSourceDir,
+        deps.readFileSync,
+      );
+      const filePath = path.join(deps.cwd, 'CONVENTIONS.md');
+      upsertMarkedSection(filePath, content, deps);
+      deps.log(`  ✓ CONVENTIONS.md`);
+    },
+  },
+};
+
+/**
+ * Installs DataQueue agent rules for the selected AI client.
+ *
+ * @param deps - Injectable dependencies for testing.
+ */
+export async function runInstallRules({
+  log = console.log,
+  error = console.error,
+  exit = (code: number) => process.exit(code),
+  cwd = process.cwd(),
+  readFileSync = fs.readFileSync,
+  writeFileSync = fs.writeFileSync,
+  appendFileSync = fs.appendFileSync,
+  mkdirSync = fs.mkdirSync,
+  existsSync = fs.existsSync,
+  rulesSourceDir = path.join(__dirname, '../ai/rules'),
+  selectedClient,
+}: InstallRulesDeps = {}): Promise<void> {
+  log('DataQueue Agent Rules Installer\n');
+  log('Select your AI client:\n');
+
+  for (const [key, client] of Object.entries(CLIENTS)) {
+    log(`  ${key}) ${client.label}`);
+  }
+  log('');
+
+  let choice = selectedClient;
+
+  if (!choice) {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    choice = await new Promise<string>((resolve) => {
+      rl.question('Enter choice (1-5): ', (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    });
+  }
+
+  const client = CLIENTS[choice];
+  if (!client) {
+    error(`Invalid choice: "${choice}". Expected 1-5.`);
+    exit(1);
+    return;
+  }
+
+  log(`\nInstalling rules for ${client.label}...`);
+
+  try {
+    client.install({
+      cwd,
+      readFileSync,
+      writeFileSync,
+      appendFileSync,
+      mkdirSync,
+      existsSync,
+      log,
+      rulesSourceDir,
+    });
+    log('\nDone!');
+  } catch (err) {
+    error('Failed to install rules:', err);
+    exit(1);
+  }
+}

package/src/install-skills-command.test.ts

@@ -0,0 +1,176 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import {
+  runInstallSkills,
+  detectAiTools,
+  InstallSkillsDeps,
+} from './install-skills-command.js';
+
+describe('detectAiTools', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('detects Cursor when .cursor directory exists', () => {
+    // Setup
+    const existsSync = vi.fn((p: string) => p.endsWith('.cursor'));
+
+    // Act
+    const tools = detectAiTools('/project', existsSync);
+
+    // Assert
+    expect(tools).toEqual([{ name: 'Cursor', targetDir: '.cursor/skills' }]);
+  });
+
+  it('detects multiple AI tools', () => {
+    // Setup
+    const existsSync = vi.fn(() => true);
+
+    // Act
+    const tools = detectAiTools('/project', existsSync);
+
+    // Assert
+    expect(tools).toHaveLength(3);
+    expect(tools.map((t) => t.name)).toEqual([
+      'Cursor',
+      'Claude Code',
+      'GitHub Copilot',
+    ]);
+  });
+
+  it('returns empty array when no tools detected', () => {
+    // Setup
+    const existsSync = vi.fn(() => false);
+
+    // Act
+    const tools = detectAiTools('/project', existsSync);
+
+    // Assert
+    expect(tools).toEqual([]);
+  });
+});
+
+describe('runInstallSkills', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  function makeDeps(
+    overrides: Partial<InstallSkillsDeps> = {},
+  ): InstallSkillsDeps {
+    return {
+      log: vi.fn(),
+      error: vi.fn(),
+      exit: vi.fn(),
+      cwd: '/project',
+      existsSync: vi.fn((p: string) => p.endsWith('.cursor')),
+      mkdirSync: vi.fn(),
+      copyFileSync: vi.fn(),
+      readdirSync: vi.fn(() => ['SKILL.md']),
+      skillsSourceDir: '/pkg/ai/skills',
+      ...overrides,
+    };
+  }
+
+  it('installs skills for detected AI tools', () => {
+    // Setup
+    const deps = makeDeps();
+
+    // Act
+    runInstallSkills(deps);
+
+    // Assert
+    expect(deps.mkdirSync).toHaveBeenCalledTimes(3);
+    expect(deps.copyFileSync).toHaveBeenCalledTimes(3);
+    expect(deps.log).toHaveBeenCalledWith(
+      expect.stringContaining('Done! Installed 3 skill(s)'),
+    );
+  });
+
+  it('creates .cursor/skills as default when no AI tools detected', () => {
+    // Setup
+    const deps = makeDeps({
+      existsSync: vi.fn(() => false),
+    });
+
+    // Act
+    runInstallSkills(deps);
+
+    // Assert
+    expect(deps.log).toHaveBeenCalledWith(
+      expect.stringContaining('Creating .cursor/skills/'),
+    );
+    expect(deps.mkdirSync).toHaveBeenCalled();
+  });
+
+  it('copies each SKILL.md file to the target directory', () => {
+    // Setup
+    const deps = makeDeps();
+
+    // Act
+    runInstallSkills(deps);
+
+    // Assert
+    expect(deps.copyFileSync).toHaveBeenCalledWith(
+      '/pkg/ai/skills/dataqueue-core/SKILL.md',
+      '/project/.cursor/skills/dataqueue-core/SKILL.md',
+    );
+    expect(deps.copyFileSync).toHaveBeenCalledWith(
+      '/pkg/ai/skills/dataqueue-advanced/SKILL.md',
+      '/project/.cursor/skills/dataqueue-advanced/SKILL.md',
+    );
+    expect(deps.copyFileSync).toHaveBeenCalledWith(
+      '/pkg/ai/skills/dataqueue-react/SKILL.md',
+      '/project/.cursor/skills/dataqueue-react/SKILL.md',
+    );
+  });
+
+  it('handles copy errors gracefully', () => {
+    // Setup
+    const deps = makeDeps({
+      copyFileSync: vi.fn(() => {
+        throw new Error('permission denied');
+      }),
+    });
+
+    // Act
+    runInstallSkills(deps);
+
+    // Assert
+    expect(deps.error).toHaveBeenCalledWith(
+      expect.stringContaining('Failed to install'),
+      expect.any(Error),
+    );
+  });
+
+  it('exits with code 1 when all installs fail', () => {
+    // Setup
+    const deps = makeDeps({
+      readdirSync: vi.fn(() => {
+        throw new Error('not found');
+      }),
+    });
+
+    // Act
+    runInstallSkills(deps);
+
+    // Assert
+    expect(deps.error).toHaveBeenCalledWith('No skills were installed.');
+    expect(deps.exit).toHaveBeenCalledWith(1);
+  });
+
+  it('installs for multiple detected tools', () => {
+    // Setup
+    const deps = makeDeps({
+      existsSync: vi.fn(() => true),
+    });
+
+    // Act
+    runInstallSkills(deps);
+
+    // Assert
+    expect(deps.mkdirSync).toHaveBeenCalledTimes(9);
+    expect(deps.log).toHaveBeenCalledWith(
+      expect.stringContaining('Cursor, Claude Code, GitHub Copilot'),
+    );
+  });
+});