gsd-remix 1.0.0

package/sdk/src/query/decomposed-handlers.test.ts

@@ -0,0 +1,365 @@
+/**
+ * Cross-module handler tests for code decomposed from the legacy `stubs.ts` module.
+ *
+ * Each suite imports real handlers from their domain modules and exercises behavior
+ * against temp fixtures (no standalone stubs).
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdtemp, writeFile, mkdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { agentSkills } from './skills.js';
+import { roadmapUpdatePlanProgress } from './roadmap-update-plan-progress.js';
+import { requirementsMarkComplete } from './roadmap.js';
+import { statePlannedPhase } from './state-mutation.js';
+import { verifySchemaDrift } from './verify.js';
+import { todoMatchPhase, statsJson, progressBar } from './progress.js';
+import { milestoneComplete } from './phase-lifecycle.js';
+import { summaryExtract, historyDigest } from './summary.js';
+import { commitToSubrepo } from './commit.js';
+import {
+  workstreamList, workstreamCreate, workstreamSet,
+  workstreamStatus, workstreamComplete,
+} from './workstream.js';
+import { docsInit } from './docs-init.js';
+import { websearch } from './websearch.js';
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = await mkdtemp(join(tmpdir(), 'gsd-stubs-'));
+  await mkdir(join(tmpDir, '.planning', 'phases', '09-foundation'), { recursive: true });
+  await mkdir(join(tmpDir, '.planning', 'phases', '10-queries'), { recursive: true });
+
+  await writeFile(join(tmpDir, '.planning', 'config.json'), JSON.stringify({
+    model_profile: 'balanced',
+    commit_docs: false,
+    git: { branching_strategy: 'none' },
+    workflow: {},
+  }));
+  await writeFile(join(tmpDir, '.planning', 'STATE.md'), '---\nmilestone: v3.0\n---\n# State\n');
+  await writeFile(join(tmpDir, '.planning', 'ROADMAP.md'), [
+    '# Roadmap',
+    '## v3.0: Test',
+    '### Phase 9: Foundation',
+    '**Goal:** Build it',
+    '- [ ] Plan 1',
+    '### Phase 10: Queries',
+    '**Goal:** Query it',
+  ].join('\n'));
+  await writeFile(join(tmpDir, '.planning', 'REQUIREMENTS.md'), [
+    '# Requirements',
+    '- [ ] REQ-01: First requirement',
+    '- [ ] REQ-02: Second requirement',
+    '- [x] REQ-03: Already done',
+  ].join('\n'));
+
+  await writeFile(join(tmpDir, '.planning', 'phases', '09-foundation', '09-01-PLAN.md'), '---\nphase: 09\nplan: 01\ntype: execute\nmust_haves:\n  truths: []\n---');
+  await writeFile(join(tmpDir, '.planning', 'phases', '09-foundation', '09-01-SUMMARY.md'), '# Done');
+  await writeFile(join(tmpDir, '.planning', 'phases', '10-queries', '10-01-PLAN.md'), '---\nphase: 10\nplan: 01\ntype: execute\nmust_haves:\n  truths: []\n---');
+});
+
+afterEach(async () => {
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
+// ─── skills.ts ───────────────────────────────────────────────────────────
+
+describe('agentSkills', () => {
+  it('returns valid QueryResult with skills array', async () => {
+    const result = await agentSkills(['gsd-executor'], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(Array.isArray(data.skills)).toBe(true);
+    expect(typeof data.skill_count).toBe('number');
+    expect(data.agent_type).toBe('gsd-executor');
+  });
+});
+
+// ─── roadmap.ts ──────────────────────────────────────────────────────────
+
+describe('roadmapUpdatePlanProgress', () => {
+  it('returns QueryResult without error', async () => {
+    const result = await roadmapUpdatePlanProgress(['9'], tmpDir);
+    expect(result.data).toBeDefined();
+    const data = result.data as Record<string, unknown>;
+    expect(typeof data.updated).toBe('boolean');
+  });
+
+  it('throws when no phase arg', async () => {
+    await expect(roadmapUpdatePlanProgress([], tmpDir)).rejects.toThrow();
+  });
+});
+
+describe('requirementsMarkComplete', () => {
+  it('returns QueryResult without error', async () => {
+    const result = await requirementsMarkComplete(['REQ-01'], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(typeof data.updated).toBe('boolean');
+  });
+
+  it('throws when no IDs provided', async () => {
+    await expect(requirementsMarkComplete([], tmpDir)).rejects.toThrow();
+  });
+});
+
+// ─── state-mutation.ts ───────────────────────────────────────────────────
+
+describe('statePlannedPhase', () => {
+  it('returns cmdStatePlannedPhase-shaped data', async () => {
+    const result = await statePlannedPhase(['--phase', '10', '--name', 'queries', '--plans', '2'], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(Array.isArray(data.updated)).toBe(true);
+    expect(data.phase).toBe('10');
+    expect(data.plan_count).toBe(2);
+  });
+
+  it('returns error when --phase is missing', async () => {
+    const result = await statePlannedPhase([], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.error).toMatch(/phase required/);
+  });
+});
+
+// ─── verify.ts ───────────────────────────────────────────────────────────
+
+describe('verifySchemaDrift', () => {
+  it('returns drift_detected shape (cmdVerifySchemaDrift parity)', async () => {
+    const result = await verifySchemaDrift(['9'], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(typeof data.drift_detected).toBe('boolean');
+    expect(typeof data.blocking).toBe('boolean');
+    expect(Array.isArray(data.schema_files)).toBe(true);
+  });
+});
+
+// ─── progress.ts ─────────────────────────────────────────────────────────
+
+describe('todoMatchPhase', () => {
+  it('returns matches and todo_count (cmdTodoMatchPhase parity)', async () => {
+    const result = await todoMatchPhase(['9'], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(Array.isArray(data.matches)).toBe(true);
+    expect(data.phase).toBe('9');
+    expect(typeof data.todo_count).toBe('number');
+  });
+});
+
+describe('statsJson', () => {
+  it('returns cmdStats JSON shape with phases table and git fields', async () => {
+    const result = await statsJson([], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(typeof data.milestone_version).toBe('string');
+    expect(Array.isArray(data.phases)).toBe(true);
+    expect(typeof data.phases_total).toBe('number');
+    expect(typeof data.total_plans).toBe('number');
+    expect(typeof data.percent).toBe('number');
+    expect((data.phases_total as number)).toBeGreaterThanOrEqual(2);
+    expect(typeof data.git_commits).toBe('number');
+  });
+});
+
+describe('progressBar', () => {
+  it('returns bar string and percent', async () => {
+    const result = await progressBar([], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(typeof data.bar).toBe('string');
+    expect(typeof data.percent).toBe('number');
+    expect(data.bar as string).toContain('[');
+  });
+});
+
+// ─── summary.ts ──────────────────────────────────────────────────────────
+
+describe('summaryExtract', () => {
+  it('returns error when file not found', async () => {
+    const result = await summaryExtract(['.planning/nonexistent.md'], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.error).toBeDefined();
+  });
+
+  it('extracts frontmatter fields from an existing summary file', async () => {
+    const summaryPath = join(tmpDir, '.planning', 'phases', '09-foundation', '09-01-SUMMARY.md');
+    await writeFile(
+      summaryPath,
+      ['---', 'phase: "09"', 'one-liner: Built it.', 'key-files:', '  - x.ts', '---', '', '# Summary', ''].join('\n'),
+      'utf-8',
+    );
+    const result = await summaryExtract(['.planning/phases/09-foundation/09-01-SUMMARY.md'], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.one_liner).toBe('Built it.');
+    expect(data.key_files).toEqual(['x.ts']);
+  });
+});
+
+describe('historyDigest', () => {
+  it('returns phases object with completed summaries', async () => {
+    const result = await historyDigest([], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(typeof data.phases).toBe('object');
+    expect(Array.isArray(data.decisions)).toBe(true);
+    expect(Array.isArray(data.tech_stack)).toBe(true);
+  });
+});
+
+// ─── workstream.ts ───────────────────────────────────────────────────────
+
+describe('workstream handlers', () => {
+  it('workstreamList returns workstreams array', async () => {
+    const result = await workstreamList([], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(Array.isArray(data.workstreams)).toBe(true);
+  });
+
+  it('workstreamCreate creates a directory', async () => {
+    const result = await workstreamCreate(['my-ws'], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(typeof data.created).toBe('boolean');
+  });
+
+  it('workstreamCreate rejects path traversal', async () => {
+    const result = await workstreamCreate(['../../bad'], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.created).toBe(false);
+  });
+
+  it('workstreamSet returns set=true for existing workstream', async () => {
+    await mkdir(join(tmpDir, '.planning', 'workstreams', 'backend'), { recursive: true });
+    const result = await workstreamSet(['backend'], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.set).toBe(true);
+    expect(data.active).toBe('backend');
+  });
+
+  it('workstreamStatus returns found boolean', async () => {
+    const result = await workstreamStatus(['nonexistent'], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(typeof data.found).toBe('boolean');
+  });
+
+  it('workstreamComplete archives existing workstream', async () => {
+    await mkdir(join(tmpDir, '.planning', 'workstreams', 'my-ws', 'phases'), { recursive: true });
+    await writeFile(join(tmpDir, '.planning', 'workstreams', 'my-ws', 'STATE.md'), '# State\n');
+    const result = await workstreamComplete(['my-ws'], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.completed).toBe(true);
+    expect(data.archived_to).toBeDefined();
+  });
+});
+
+// ─── init.ts ─────────────────────────────────────────────────────────────
+
+describe('docsInit', () => {
+  it('returns docs context matching gsd-tools docs-init', async () => {
+    const result = await docsInit([], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(typeof data.planning_exists).toBe('boolean');
+    expect(data.project_root).toBe(tmpDir);
+    expect(typeof data.doc_writer_model).toBe('string');
+    expect(Array.isArray(data.existing_docs)).toBe(true);
+    expect(data.project_type).toBeDefined();
+    expect(data.doc_tooling).toBeDefined();
+    expect(Array.isArray(data.monorepo_workspaces)).toBe(true);
+    expect(typeof data.agents_installed).toBe('boolean');
+    expect(Array.isArray(data.missing_agents)).toBe(true);
+  });
+});
+
+// ─── websearch.ts ────────────────────────────────────────────────────────
+
+describe('websearch', () => {
+  const originalEnv = process.env.BRAVE_API_KEY;
+
+  afterEach(() => {
+    if (originalEnv === undefined) {
+      delete process.env.BRAVE_API_KEY;
+    } else {
+      process.env.BRAVE_API_KEY = originalEnv;
+    }
+    vi.restoreAllMocks();
+  });
+
+  it('returns available:false when BRAVE_API_KEY is not set', async () => {
+    delete process.env.BRAVE_API_KEY;
+    const result = await websearch([], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.available).toBe(false);
+    expect(data.reason).toBe('BRAVE_API_KEY not set');
+  });
+
+  it('returns error when query is empty', async () => {
+    process.env.BRAVE_API_KEY = 'test-key';
+    const result = await websearch([], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.available).toBe(false);
+    expect(data.error).toBe('Query required');
+  });
+
+  it('returns results on successful API call', async () => {
+    process.env.BRAVE_API_KEY = 'test-key';
+    const mockResults = {
+      web: {
+        results: [
+          { title: 'Result 1', url: 'https://example.com', description: 'Desc 1', age: '2d' },
+          { title: 'Result 2', url: 'https://example.org', description: 'Desc 2' },
+        ],
+      },
+    };
+
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      ok: true,
+      json: async () => mockResults,
+    } as Response);
+
+    const result = await websearch(['typescript generics'], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.available).toBe(true);
+    expect(data.query).toBe('typescript generics');
+    expect(data.count).toBe(2);
+    const results = data.results as Array<Record<string, unknown>>;
+    expect(results[0].title).toBe('Result 1');
+    expect(results[0].age).toBe('2d');
+    expect(results[1].age).toBeNull();
+  });
+
+  it('passes --limit and --freshness params to API', async () => {
+    process.env.BRAVE_API_KEY = 'test-key';
+
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      ok: true,
+      json: async () => ({ web: { results: [] } }),
+    } as Response);
+
+    await websearch(['query', '--limit', '5', '--freshness', 'week'], tmpDir);
+
+    const url = new URL((globalThis.fetch as ReturnType<typeof vi.fn>).mock.calls[0][0] as string);
+    expect(url.searchParams.get('count')).toBe('5');
+    expect(url.searchParams.get('freshness')).toBe('week');
+  });
+
+  it('returns error on non-ok response', async () => {
+    process.env.BRAVE_API_KEY = 'test-key';
+
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      ok: false,
+      status: 429,
+    } as Response);
+
+    const result = await websearch(['rate limited query'], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.available).toBe(false);
+    expect(data.error).toBe('API error: 429');
+  });
+
+  it('returns error on network failure', async () => {
+    process.env.BRAVE_API_KEY = 'test-key';
+
+    vi.spyOn(globalThis, 'fetch').mockRejectedValue(new Error('ECONNREFUSED'));
+
+    const result = await websearch(['network fail'], tmpDir);
+    const data = result.data as Record<string, unknown>;
+    expect(data.available).toBe(false);
+    expect(data.error).toBe('ECONNREFUSED');
+  });
+});

package/sdk/src/query/detect-custom-files.ts

@@ -0,0 +1,97 @@
+/**
+ * Detect user-added files under GSD-managed install dirs not listed in the manifest.
+ *
+ * Port of `detect-custom-files` from `get-shit-done/bin/gsd-tools.cjs` (lines 1161–1239).
+ */
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+
+import type { QueryHandler } from './utils.js';
+
+const GSD_MANAGED_DIRS = [
+  'get-shit-done',
+  'agents',
+  join('commands', 'gsd'),
+  'hooks',
+  'command',
+  'skills',
+];
+
+function walkDir(dir: string, baseDir: string): string[] {
+  const results: string[] = [];
+  if (!existsSync(dir)) return results;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walkDir(fullPath, baseDir));
+    } else {
+      const relPath = relative(baseDir, fullPath).split('\\').join('/');
+      results.push(relPath);
+    }
+  }
+  return results;
+}
+
+/**
+ * Args: `--config-dir <path>` (required) — runtime config directory to scan.
+ */
+export const detectCustomFiles: QueryHandler = async (args) => {
+  const configDirIdx = args.indexOf('--config-dir');
+  const configDir = configDirIdx !== -1 ? args[configDirIdx + 1] : null;
+  if (!configDir) {
+    return { data: { error: 'Usage: detect-custom-files --config-dir <path>' } };
+  }
+
+  const resolvedConfigDir = resolve(configDir);
+  if (!existsSync(resolvedConfigDir)) {
+    return { data: { error: `Config directory not found: ${resolvedConfigDir}` } };
+  }
+
+  const manifestPath = join(resolvedConfigDir, 'gsd-file-manifest.json');
+  if (!existsSync(manifestPath)) {
+    return {
+      data: {
+        custom_files: [] as string[],
+        custom_count: 0,
+        manifest_found: false,
+      },
+    };
+  }
+
+  let manifest: { version?: string; files?: Record<string, unknown> };
+  try {
+    manifest = JSON.parse(readFileSync(manifestPath, 'utf8')) as { version?: string; files?: Record<string, unknown> };
+  } catch {
+    return {
+      data: {
+        custom_files: [] as string[],
+        custom_count: 0,
+        manifest_found: false,
+        error: 'manifest parse error',
+      },
+    };
+  }
+
+  const manifestKeys = new Set(Object.keys(manifest.files || {}));
+
+  const customFiles: string[] = [];
+  for (const managedDir of GSD_MANAGED_DIRS) {
+    const absDir = join(resolvedConfigDir, managedDir);
+    if (!existsSync(absDir)) continue;
+    for (const relPath of walkDir(absDir, resolvedConfigDir)) {
+      if (!manifestKeys.has(relPath)) {
+        customFiles.push(relPath);
+      }
+    }
+  }
+
+  return {
+    data: {
+      custom_files: customFiles,
+      custom_count: customFiles.length,
+      manifest_found: true,
+      manifest_version: manifest.version ?? null,
+    },
+  };
+};

package/sdk/src/query/detect-phase-type.test.ts

@@ -0,0 +1,105 @@
+/**
+ * Unit tests for `detect.phase-type` (decision-routing audit §3.6).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdir, writeFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { detectPhaseType } from './detect-phase-type.js';
+
+describe('detectPhaseType', () => {
+  let projectDir: string;
+
+  beforeEach(async () => {
+    projectDir = join(tmpdir(), `gsd-detect-phase-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    await mkdir(join(projectDir, '.planning', 'phases'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(projectDir, { recursive: true, force: true });
+  });
+
+  it('throws when phase arg is missing', async () => {
+    await expect(detectPhaseType([], projectDir)).rejects.toThrow();
+  });
+
+  it('returns all false/null/[] when phase dir does not exist', async () => {
+    const { data } = await detectPhaseType(['99'], projectDir);
+    const d = data as Record<string, unknown>;
+    expect(d.has_frontend).toBe(false);
+    expect(d.has_schema).toBe(false);
+    expect(d.schema_orm).toBeNull();
+    expect(d.schema_files).toEqual([]);
+    expect(d.frontend_indicators).toEqual([]);
+    expect(d.has_api).toBe(false);
+    expect(d.has_infra).toBe(false);
+  });
+
+  it('sets has_frontend true when ROADMAP heading contains UI keyword', async () => {
+    const roadmapContent = `# Project Roadmap\n\n## Phase 01: UI Dashboard\n\nSome content\n`;
+    await writeFile(join(projectDir, '.planning', 'ROADMAP.md'), roadmapContent, 'utf-8');
+    await mkdir(join(projectDir, '.planning', 'phases', '01-ui-dashboard'), { recursive: true });
+
+    const { data } = await detectPhaseType(['1'], projectDir);
+    const d = data as Record<string, unknown>;
+    expect(d.has_frontend).toBe(true);
+    expect((d.frontend_indicators as string[]).length).toBeGreaterThan(0);
+  });
+
+  it('sets has_schema true and schema_orm prisma when prisma schema file found', async () => {
+    const phaseDir = join(projectDir, '.planning', 'phases', '02-database');
+    await mkdir(join(phaseDir, 'prisma'), { recursive: true });
+    await writeFile(join(phaseDir, 'prisma', 'schema.prisma'), 'model User {}', 'utf-8');
+
+    const { data } = await detectPhaseType(['2'], projectDir);
+    const d = data as Record<string, unknown>;
+    expect(d.has_schema).toBe(true);
+    expect(d.schema_orm).toBe('prisma');
+    expect((d.schema_files as string[]).length).toBeGreaterThan(0);
+  });
+
+  it('sets has_frontend true when UI-SPEC.md is present in phase dir', async () => {
+    const phaseDir = join(projectDir, '.planning', 'phases', '03-features');
+    await mkdir(phaseDir, { recursive: true });
+    await writeFile(join(phaseDir, 'UI-SPEC.md'), '# UI Spec', 'utf-8');
+
+    const { data } = await detectPhaseType(['3'], projectDir);
+    const d = data as Record<string, unknown>;
+    expect(d.has_frontend).toBe(true);
+  });
+
+  it('sets has_api true when route file found in phase dir', async () => {
+    const phaseDir = join(projectDir, '.planning', 'phases', '04-api');
+    await mkdir(phaseDir, { recursive: true });
+    await writeFile(join(phaseDir, 'user.route.ts'), 'export {}', 'utf-8');
+
+    const { data } = await detectPhaseType(['4'], projectDir);
+    const d = data as Record<string, unknown>;
+    expect(d.has_api).toBe(true);
+  });
+
+  it('sets has_infra true when docker file found in phase dir', async () => {
+    const phaseDir = join(projectDir, '.planning', 'phases', '05-infra');
+    await mkdir(phaseDir, { recursive: true });
+    await writeFile(join(phaseDir, 'dockerfile.yml'), '', 'utf-8');
+
+    const { data } = await detectPhaseType(['5'], projectDir);
+    const d = data as Record<string, unknown>;
+    expect(d.has_infra).toBe(true);
+  });
+
+  it('returns push_command null (reserved field)', async () => {
+    await mkdir(join(projectDir, '.planning', 'phases', '06-misc'), { recursive: true });
+    const { data } = await detectPhaseType(['6'], projectDir);
+    const d = data as Record<string, unknown>;
+    expect(d.push_command).toBeNull();
+  });
+
+  it('returns correct phase field in output', async () => {
+    await mkdir(join(projectDir, '.planning', 'phases', '07-test'), { recursive: true });
+    const { data } = await detectPhaseType(['7'], projectDir);
+    const d = data as Record<string, unknown>;
+    expect(d.phase).toBe('07');
+  });
+});