@nicnocquee/dataqueue 1.33.0 → 1.34.0

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'),
+    );
+  });
+});

package/src/install-skills-command.ts

@@ -0,0 +1,124 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export interface InstallSkillsDeps {
+  log?: (...args: unknown[]) => void;
+  error?: (...args: unknown[]) => void;
+  exit?: (code: number) => void;
+  cwd?: string;
+  existsSync?: (p: string) => boolean;
+  mkdirSync?: (p: string, opts?: fs.MakeDirectoryOptions) => void;
+  copyFileSync?: (src: string, dest: string) => void;
+  readdirSync?: (p: string) => string[];
+  skillsSourceDir?: string;
+}
+
+const SKILL_DIRS = ['dataqueue-core', 'dataqueue-advanced', 'dataqueue-react'];
+
+interface AiTool {
+  name: string;
+  targetDir: string;
+}
+
+/**
+ * Detects which AI tools have config directories in the project.
+ *
+ * @param cwd - Current working directory to scan.
+ * @param existsSync - Injectable fs.existsSync.
+ * @returns Array of detected AI tools with their skills target directories.
+ */
+export function detectAiTools(
+  cwd: string,
+  existsSync: (p: string) => boolean = fs.existsSync,
+): AiTool[] {
+  const tools: AiTool[] = [];
+  const checks: Array<{ name: string; indicator: string; targetDir: string }> =
+    [
+      {
+        name: 'Cursor',
+        indicator: '.cursor',
+        targetDir: '.cursor/skills',
+      },
+      {
+        name: 'Claude Code',
+        indicator: '.claude',
+        targetDir: '.claude/skills',
+      },
+      {
+        name: 'GitHub Copilot',
+        indicator: '.github',
+        targetDir: '.github/skills',
+      },
+    ];
+
+  for (const check of checks) {
+    if (existsSync(path.join(cwd, check.indicator))) {
+      tools.push({ name: check.name, targetDir: check.targetDir });
+    }
+  }
+
+  return tools;
+}
+
+/**
+ * Installs DataQueue skill files into detected AI tool directories.
+ *
+ * @param deps - Injectable dependencies for testing.
+ */
+export function runInstallSkills({
+  log = console.log,
+  error = console.error,
+  exit = (code: number) => process.exit(code),
+  cwd = process.cwd(),
+  existsSync = fs.existsSync,
+  mkdirSync = fs.mkdirSync,
+  copyFileSync = fs.copyFileSync,
+  readdirSync = fs.readdirSync,
+  skillsSourceDir = path.join(__dirname, '../ai/skills'),
+}: InstallSkillsDeps = {}): void {
+  const tools = detectAiTools(cwd, existsSync);
+
+  if (tools.length === 0) {
+    log('No AI tool directories detected (.cursor/, .claude/, .github/).');
+    log('Creating .cursor/skills/ as the default target.');
+    tools.push({ name: 'Cursor', targetDir: '.cursor/skills' });
+  }
+
+  let installed = 0;
+
+  for (const tool of tools) {
+    log(`\nInstalling skills for ${tool.name}...`);
+
+    for (const skillDir of SKILL_DIRS) {
+      const srcDir = path.join(skillsSourceDir, skillDir);
+      const destDir = path.join(cwd, tool.targetDir, skillDir);
+
+      try {
+        mkdirSync(destDir, { recursive: true });
+
+        const files = readdirSync(srcDir);
+        for (const file of files) {
+          copyFileSync(path.join(srcDir, file), path.join(destDir, file));
+        }
+
+        log(`  ✓ ${skillDir}`);
+        installed++;
+      } catch (err) {
+        error(`  ✗ Failed to install ${skillDir}:`, err);
+      }
+    }
+  }
+
+  if (installed > 0) {
+    log(
+      `\nDone! Installed ${installed} skill(s) for ${tools.map((t) => t.name).join(', ')}.`,
+    );
+  } else {
+    error('No skills were installed.');
+    exit(1);
+  }
+}

package/src/mcp-server.test.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect } from 'vitest';
+import {
+  loadDocsContent,
+  scorePageForQuery,
+  extractExcerpt,
+} from './mcp-server.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const DOCS_CONTENT_PATH = path.join(__dirname, '../ai/docs-content.json');
+
+describe('loadDocsContent', () => {
+  it('loads the docs-content.json file', () => {
+    // Act
+    const pages = loadDocsContent(DOCS_CONTENT_PATH);
+
+    // Assert
+    expect(pages.length).toBeGreaterThan(0);
+    expect(pages[0]).toHaveProperty('slug');
+    expect(pages[0]).toHaveProperty('title');
+    expect(pages[0]).toHaveProperty('content');
+  });
+
+  it('throws for non-existent file', () => {
+    // Act & Assert
+    expect(() => loadDocsContent('/nonexistent/path.json')).toThrow();
+  });
+});
+
+describe('scorePageForQuery', () => {
+  it('scores title matches highest', () => {
+    // Setup
+    const page = {
+      slug: 'test',
+      title: 'Cron Jobs',
+      description: 'Schedule recurring tasks',
+      content: 'Use cron expressions.',
+    };
+
+    // Act
+    const score = scorePageForQuery(page, ['cron']);
+
+    // Assert
+    expect(score).toBeGreaterThanOrEqual(10);
+  });
+
+  it('scores description matches', () => {
+    // Setup
+    const page = {
+      slug: 'test',
+      title: 'Other Page',
+      description: 'Schedule recurring cron tasks',
+      content: 'No match in content.',
+    };
+
+    // Act
+    const score = scorePageForQuery(page, ['cron']);
+
+    // Assert
+    expect(score).toBeGreaterThanOrEqual(5);
+  });
+
+  it('scores content matches', () => {
+    // Setup
+    const page = {
+      slug: 'test',
+      title: 'Other',
+      description: 'Other',
+      content: 'Use cron for scheduling. Cron is powerful.',
+    };
+
+    // Act
+    const score = scorePageForQuery(page, ['cron']);
+
+    // Assert
+    expect(score).toBeGreaterThan(0);
+  });
+
+  it('returns 0 for no matches', () => {
+    // Setup
+    const page = {
+      slug: 'test',
+      title: 'Unrelated',
+      description: 'Nothing here',
+      content: 'No match.',
+    };
+
+    // Act
+    const score = scorePageForQuery(page, ['zzzzzzz']);
+
+    // Assert
+    expect(score).toBe(0);
+  });
+
+  it('handles multiple query terms', () => {
+    // Setup
+    const page = {
+      slug: 'test',
+      title: 'Cron Jobs',
+      description: 'Schedule tasks',
+      content: 'timeout and cron are related.',
+    };
+
+    // Act
+    const scoreMulti = scorePageForQuery(page, ['cron', 'timeout']);
+    const scoreSingle = scorePageForQuery(page, ['cron']);
+
+    // Assert
+    expect(scoreMulti).toBeGreaterThan(scoreSingle);
+  });
+});
+
+describe('extractExcerpt', () => {
+  it('extracts content around the first matching term', () => {
+    // Setup
+    const content = 'A'.repeat(200) + 'target keyword here' + 'B'.repeat(200);
+
+    // Act
+    const excerpt = extractExcerpt(content, ['target']);
+
+    // Assert
+    expect(excerpt).toContain('target keyword here');
+    expect(excerpt.length).toBeLessThanOrEqual(510);
+  });
+
+  it('returns beginning of content when no match found', () => {
+    // Setup
+    const content = 'This is the beginning of the content. More content here.';
+
+    // Act
+    const excerpt = extractExcerpt(content, ['nonexistent']);
+
+    // Assert
+    expect(excerpt).toBe(content);
+  });
+
+  it('adds ellipsis when excerpt is truncated', () => {
+    // Setup
+    const content = 'A'.repeat(300) + 'match' + 'B'.repeat(300);
+
+    // Act
+    const excerpt = extractExcerpt(content, ['match'], 200);
+
+    // Assert
+    expect(excerpt.startsWith('...')).toBe(true);
+    expect(excerpt.endsWith('...')).toBe(true);
+  });
+
+  it('respects maxLength parameter', () => {
+    // Setup
+    const content = 'A'.repeat(1000);
+
+    // Act
+    const excerpt = extractExcerpt(content, ['nonexistent'], 100);
+
+    // Assert
+    expect(excerpt.length).toBeLessThanOrEqual(100);
+  });
+});

package/src/mcp-server.ts

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+
+/**
+ * DataQueue MCP Server — exposes documentation search over stdio.
+ * Run via: dataqueue-cli mcp
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+interface DocPage {
+  slug: string;
+  title: string;
+  description: string;
+  content: string;
+}
+
+/** @internal Loads docs-content.json from the ai/ directory bundled with the package. */
+export function loadDocsContent(
+  docsPath: string = path.join(__dirname, '../ai/docs-content.json'),
+): DocPage[] {
+  const raw = fs.readFileSync(docsPath, 'utf-8');
+  return JSON.parse(raw) as DocPage[];
+}
+
+/** @internal Scores a doc page against a search query using simple term matching. */
+export function scorePageForQuery(page: DocPage, queryTerms: string[]): number {
+  const titleLower = page.title.toLowerCase();
+  const descLower = page.description.toLowerCase();
+  const contentLower = page.content.toLowerCase();
+
+  let score = 0;
+  for (const term of queryTerms) {
+    if (titleLower.includes(term)) score += 10;
+    if (descLower.includes(term)) score += 5;
+
+    const contentMatches = contentLower.split(term).length - 1;
+    score += Math.min(contentMatches, 10);
+  }
+  return score;
+}
+
+/** @internal Extracts a relevant excerpt around the first match of any query term. */
+export function extractExcerpt(
+  content: string,
+  queryTerms: string[],
+  maxLength = 500,
+): string {
+  const lower = content.toLowerCase();
+  let earliestIndex = -1;
+
+  for (const term of queryTerms) {
+    const idx = lower.indexOf(term);
+    if (idx !== -1 && (earliestIndex === -1 || idx < earliestIndex)) {
+      earliestIndex = idx;
+    }
+  }
+
+  if (earliestIndex === -1) {
+    return content.slice(0, maxLength);
+  }
+
+  const start = Math.max(0, earliestIndex - 100);
+  const end = Math.min(content.length, start + maxLength);
+  let excerpt = content.slice(start, end);
+
+  if (start > 0) excerpt = '...' + excerpt;
+  if (end < content.length) excerpt = excerpt + '...';
+
+  return excerpt;
+}
+
+/**
+ * Creates and starts the DataQueue MCP server over stdio.
+ *
+ * @param deps - Injectable dependencies for testing.
+ */
+export async function startMcpServer(
+  deps: {
+    docsPath?: string;
+    transport?: InstanceType<typeof StdioServerTransport>;
+  } = {},
+): Promise<McpServer> {
+  const pages = loadDocsContent(deps.docsPath);
+
+  const server = new McpServer({
+    name: 'dataqueue-docs',
+    version: '1.0.0',
+  });
+
+  server.resource('llms-txt', 'dataqueue://llms.txt', async () => {
+    const llmsPath = path.join(
+      __dirname,
+      '../ai/skills/dataqueue-core/SKILL.md',
+    );
+    let content: string;
+    try {
+      content = fs.readFileSync(llmsPath, 'utf-8');
+    } catch {
+      content = pages
+        .map((p) => `## ${p.title}\n\nSlug: ${p.slug}\n\n${p.description}`)
+        .join('\n\n');
+    }
+    return { contents: [{ uri: 'dataqueue://llms.txt', text: content }] };
+  });
+
+  server.tool(
+    'list-doc-pages',
+    'List all available DataQueue documentation pages with titles and descriptions.',
+    {},
+    async () => {
+      const listing = pages.map((p) => ({
+        slug: p.slug,
+        title: p.title,
+        description: p.description,
+      }));
+      return {
+        content: [
+          { type: 'text' as const, text: JSON.stringify(listing, null, 2) },
+        ],
+      };
+    },
+  );
+
+  server.tool(
+    'get-doc-page',
+    'Fetch a specific DataQueue doc page by slug. Returns full page content as markdown.',
+    {
+      slug: z
+        .string()
+        .describe('The doc page slug, e.g. "usage/add-job" or "api/job-queue"'),
+    },
+    async ({ slug }) => {
+      const page = pages.find((p) => p.slug === slug);
+      if (!page) {
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: `Page not found: "${slug}". Use list-doc-pages to see available slugs.`,
+            },
+          ],
+          isError: true,
+        };
+      }
+      const header = page.description
+        ? `# ${page.title}\n\n> ${page.description}\n\n`
+        : `# ${page.title}\n\n`;
+      return {
+        content: [{ type: 'text' as const, text: header + page.content }],
+      };
+    },
+  );
+
+  server.tool(
+    'search-docs',
+    'Full-text search across all DataQueue documentation pages. Returns matching sections with page titles and content excerpts.',
+    {
+      query: z
+        .string()
+        .describe('Search query, e.g. "cron scheduling" or "waitForToken"'),
+    },
+    async ({ query }) => {
+      const queryTerms = query
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((t) => t.length > 1);
+
+      if (queryTerms.length === 0) {
+        return {
+          content: [
+            { type: 'text' as const, text: 'Please provide a search query.' },
+          ],
+          isError: true,
+        };
+      }
+
+      const scored = pages
+        .map((page) => ({
+          page,
+          score: scorePageForQuery(page, queryTerms),
+        }))
+        .filter((r) => r.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, 5);
+
+      if (scored.length === 0) {
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: `No results for "${query}". Try different keywords or use list-doc-pages to browse.`,
+            },
+          ],
+        };
+      }
+
+      const results = scored.map((r) => {
+        const excerpt = extractExcerpt(r.page.content, queryTerms);
+        return `## ${r.page.title} (${r.page.slug})\n\n${r.page.description}\n\n${excerpt}`;
+      });
+
+      return {
+        content: [{ type: 'text' as const, text: results.join('\n\n---\n\n') }],
+      };
+    },
+  );
+
+  const transport = deps.transport ?? new StdioServerTransport();
+  await server.connect(transport);
+  return server;
+}
+
+const isDirectRun =
+  process.argv[1] &&
+  (process.argv[1].endsWith('/mcp-server.js') ||
+    process.argv[1].endsWith('/mcp-server.cjs'));
+
+if (isDirectRun) {
+  startMcpServer().catch((err) => {
+    console.error('Failed to start MCP server:', err);
+    process.exit(1);
+  });
+}