@specmarket/cli 0.0.4 → 0.0.5

package/src/commands/whoami.test.ts

@@ -0,0 +1,106 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// --- Hoisted mocks ---
+
+const { mockQuery, mockClient, mockLoadCreds } = vi.hoisted(() => {
+  const mockQuery = vi.fn();
+  const mockClient = { query: mockQuery };
+  const mockLoadCreds = vi.fn();
+  return { mockQuery, mockClient, mockLoadCreds };
+});
+
+vi.mock('../lib/convex-client.js', () => ({
+  getConvexClient: vi.fn().mockResolvedValue(mockClient),
+}));
+
+vi.mock('../lib/auth.js', () => ({
+  loadCredentials: mockLoadCreds,
+}));
+
+vi.mock('@specmarket/convex/api', () => ({
+  api: {
+    users: { getMe: 'users.getMe' },
+  },
+}));
+
+const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+import { handleWhoami } from './whoami.js';
+
+describe('handleWhoami', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('shows not-logged-in message when no credentials exist', async () => {
+    mockLoadCreds.mockResolvedValue(null);
+
+    await handleWhoami();
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Not logged in')
+    );
+  });
+
+  it('displays full profile from Convex when available', async () => {
+    mockLoadCreds.mockResolvedValue({
+      token: 'test-token',
+      username: 'alice',
+      expiresAt: Date.now() + 30 * 24 * 3600_000,
+    });
+    mockQuery.mockResolvedValue({
+      username: 'alice',
+      displayName: 'Alice Smith',
+      role: 'user',
+      totalSpecsPublished: 5,
+      reputationScore: 120,
+    });
+
+    await handleWhoami();
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Authenticated as')
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('@alice')
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Alice Smith')
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('120')
+    );
+  });
+
+  it('falls back to cached credentials when Convex is unreachable', async () => {
+    mockLoadCreds.mockResolvedValue({
+      token: 'test-token',
+      username: 'bob',
+      expiresAt: Date.now() + 30 * 24 * 3600_000,
+    });
+    mockQuery.mockRejectedValue(new Error('Network error'));
+
+    await handleWhoami();
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Authenticated (cached)')
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('@bob')
+    );
+  });
+
+  it('shows "unknown" when cached credentials have no username', async () => {
+    mockLoadCreds.mockResolvedValue({
+      token: 'test-token',
+      expiresAt: Date.now() + 3600_000,
+    });
+    mockQuery.mockRejectedValue(new Error('Network error'));
+
+    await handleWhoami();
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('@unknown')
+    );
+  });
+});

package/src/index.ts

@@ -18,6 +18,8 @@ import { createPublishCommand } from './commands/publish.js';
 import { createForkCommand } from './commands/fork.js';
 import { createReportCommand } from './commands/report.js';
 import { createConfigCommand } from './commands/config.js';
+import { createIssuesCommand } from './commands/issues.js';
+import { createCommentCommand } from './commands/comment.js';
 import { createRequire } from 'module';
 
 // Dynamically read version from package.json so it stays in sync with npm publishes
@@ -62,6 +64,10 @@ program.addCommand(createInfoCommand());
 program.addCommand(createPublishCommand());
 program.addCommand(createForkCommand());
 
+// Collaboration
+program.addCommand(createIssuesCommand());
+program.addCommand(createCommentCommand());
+
 // Reporting & config
 program.addCommand(createReportCommand());
 program.addCommand(createConfigCommand());

package/src/lib/convex-client.ts

@@ -5,8 +5,6 @@ import createDebug from 'debug';
 
 const debug = createDebug('specmarket:convex');
 
-let _client: ConvexHttpClient | null = null;
-
 /**
  * Returns a ConvexHttpClient configured with the deployment URL and optional auth token.
  * The URL is resolved from (in priority order):
@@ -23,6 +21,12 @@ export async function getConvexClient(token?: string): Promise<ConvexHttpClient>
     config.convexUrl ??
     DEFAULT_CONVEX_URL;
 
+  if (url.includes('placeholder.convex.cloud')) {
+    throw new Error(
+      'CONVEX_URL is not configured. Set the CONVEX_URL environment variable or run `specmarket config set convexUrl <url>`.'
+    );
+  }
+
   debug('Creating Convex client for URL: %s', url);
   const client = new ConvexHttpClient(url);
 

package/src/lib/format-detection.test.ts

@@ -0,0 +1,223 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdir, writeFile, rm } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { randomUUID } from 'crypto';
+import {
+  detectSpecFormat,
+  fileExists,
+  directoryExists,
+  hasStoryFiles,
+  hasMarkdownFiles,
+  tryReadSidecar,
+} from './format-detection.js';
+
+describe('format-detection', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = join(tmpdir(), `format-det-${randomUUID()}`);
+    await mkdir(tmpDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('fileExists', () => {
+    it('returns true when file exists', async () => {
+      await writeFile(join(tmpDir, 'foo.txt'), 'hi');
+      expect(await fileExists(join(tmpDir, 'foo.txt'))).toBe(true);
+    });
+    it('returns false when file does not exist', async () => {
+      expect(await fileExists(join(tmpDir, 'nonexistent.txt'))).toBe(false);
+    });
+  });
+
+  describe('directoryExists', () => {
+    it('returns true when directory exists', async () => {
+      expect(await directoryExists(tmpDir)).toBe(true);
+    });
+    it('returns false when path does not exist', async () => {
+      expect(await directoryExists(join(tmpDir, 'nope'))).toBe(false);
+    });
+  });
+
+  describe('hasStoryFiles', () => {
+    it('returns true when story-*.md exists', async () => {
+      await writeFile(join(tmpDir, 'story-1.md'), '# Story 1');
+      expect(await hasStoryFiles(tmpDir)).toBe(true);
+    });
+    it('returns false when no story files', async () => {
+      await writeFile(join(tmpDir, 'other.md'), 'x');
+      expect(await hasStoryFiles(tmpDir)).toBe(false);
+    });
+  });
+
+  describe('hasMarkdownFiles', () => {
+    it('returns true when .md file in root', async () => {
+      await writeFile(join(tmpDir, 'readme.md'), 'x');
+      expect(await hasMarkdownFiles(tmpDir)).toBe(true);
+    });
+    it('returns true when .md in subdir', async () => {
+      await mkdir(join(tmpDir, 'docs'), { recursive: true });
+      await writeFile(join(tmpDir, 'docs', 'a.md'), 'x');
+      expect(await hasMarkdownFiles(tmpDir)).toBe(true);
+    });
+    it('returns false when no .md files', async () => {
+      await writeFile(join(tmpDir, 'file.txt'), 'x');
+      expect(await hasMarkdownFiles(tmpDir)).toBe(false);
+    });
+  });
+
+  describe('tryReadSidecar', () => {
+    it('returns spec_format when specmarket.yaml is valid', async () => {
+      await writeFile(
+        join(tmpDir, 'specmarket.yaml'),
+        'spec_format: speckit\ndisplay_name: Test\ndescription: A long enough description here.'
+      );
+      const result = await tryReadSidecar(tmpDir);
+      expect(result).toEqual({ spec_format: 'speckit' });
+    });
+    it('returns null when file does not exist', async () => {
+      expect(await tryReadSidecar(tmpDir)).toBeNull();
+    });
+    it('returns null when spec_format missing', async () => {
+      await writeFile(join(tmpDir, 'specmarket.yaml'), 'display_name: X\ndescription: Long desc.');
+      expect(await tryReadSidecar(tmpDir)).toBeNull();
+    });
+  });
+
+  describe('detectSpecFormat', () => {
+    it('empty dir → custom, low confidence', async () => {
+      const result = await detectSpecFormat(tmpDir);
+      expect(result.format).toBe('custom');
+      expect(result.confidence).toBe('low');
+      expect(result.detectedBy).toBe('heuristic');
+    });
+
+    it('legacy dir (spec.yaml + PROMPT.md + SUCCESS_CRITERIA.md) → specmarket-legacy, high', async () => {
+      await writeFile(join(tmpDir, 'spec.yaml'), 'name: x');
+      await writeFile(join(tmpDir, 'PROMPT.md'), '# P');
+      await writeFile(join(tmpDir, 'SUCCESS_CRITERIA.md'), '- [ ] C');
+      const result = await detectSpecFormat(tmpDir);
+      expect(result.format).toBe('specmarket-legacy');
+      expect(result.confidence).toBe('high');
+      expect(result.detectedBy).toBe('heuristic');
+    });
+
+    it('speckit dir (spec.md + tasks.md + .specify/) → speckit, high', async () => {
+      await writeFile(join(tmpDir, 'spec.md'), '# Spec');
+      await writeFile(join(tmpDir, 'tasks.md'), '# Tasks');
+      await mkdir(join(tmpDir, '.specify'), { recursive: true });
+      const result = await detectSpecFormat(tmpDir);
+      expect(result.format).toBe('speckit');
+      expect(result.confidence).toBe('high');
+    });
+
+    it('speckit dir (spec.md + plan.md) without .specify → speckit, high', async () => {
+      await writeFile(join(tmpDir, 'spec.md'), '# Spec');
+      await writeFile(join(tmpDir, 'plan.md'), '# Plan');
+      const result = await detectSpecFormat(tmpDir);
+      expect(result.format).toBe('speckit');
+      expect(result.confidence).toBe('high');
+    });
+
+    it('bmad dir (prd.md + architecture.md) → bmad, high', async () => {
+      await writeFile(join(tmpDir, 'prd.md'), '# PRD');
+      await writeFile(join(tmpDir, 'architecture.md'), '# Arch');
+      const result = await detectSpecFormat(tmpDir);
+      expect(result.format).toBe('bmad');
+      expect(result.confidence).toBe('high');
+    });
+
+    it('bmad dir (prd.md + story-1.md) → bmad, high', async () => {
+      await writeFile(join(tmpDir, 'prd.md'), '# PRD');
+      await writeFile(join(tmpDir, 'story-1.md'), '# Story');
+      const result = await detectSpecFormat(tmpDir);
+      expect(result.format).toBe('bmad');
+      expect(result.confidence).toBe('high');
+    });
+
+    it('ralph dir (prd.json with userStories) → ralph, high', async () => {
+      await writeFile(
+        join(tmpDir, 'prd.json'),
+        JSON.stringify({ userStories: [{ title: 'As a user I want X' }] })
+      );
+      const result = await detectSpecFormat(tmpDir);
+      expect(result.format).toBe('ralph');
+      expect(result.confidence).toBe('high');
+    });
+
+    it('ralph prd.json with empty userStories still detects ralph', async () => {
+      await writeFile(join(tmpDir, 'prd.json'), JSON.stringify({ userStories: [] }));
+      const result = await detectSpecFormat(tmpDir);
+      expect(result.format).toBe('ralph');
+      expect(result.confidence).toBe('high');
+    });
+
+    it('sidecar override: specmarket.yaml with spec_format → sidecar value, high', async () => {
+      await writeFile(join(tmpDir, 'spec.yaml'), 'x');
+      await writeFile(join(tmpDir, 'PROMPT.md'), 'x');
+      await writeFile(join(tmpDir, 'SUCCESS_CRITERIA.md'), 'x');
+      await writeFile(
+        join(tmpDir, 'specmarket.yaml'),
+        'spec_format: my-custom-format\ndisplay_name: X\ndescription: Long enough description.'
+      );
+      const result = await detectSpecFormat(tmpDir);
+      expect(result.format).toBe('my-custom-format');
+      expect(result.detectedBy).toBe('sidecar');
+      expect(result.confidence).toBe('high');
+    });
+
+    it('sidecar with invalid format string still returned as format', async () => {
+      await writeFile(
+        join(tmpDir, 'specmarket.yaml'),
+        'spec_format: unknown-format\ndisplay_name: X\ndescription: Long enough description.'
+      );
+      const result = await detectSpecFormat(tmpDir);
+      expect(result.format).toBe('unknown-format');
+      expect(result.detectedBy).toBe('sidecar');
+    });
+
+    it('mixed signals: sidecar takes priority over heuristic', async () => {
+      await writeFile(join(tmpDir, 'spec.yaml'), 'x');
+      await writeFile(join(tmpDir, 'PROMPT.md'), 'x');
+      await writeFile(join(tmpDir, 'SUCCESS_CRITERIA.md'), 'x');
+      await writeFile(
+        join(tmpDir, 'specmarket.yaml'),
+        'spec_format: speckit\ndisplay_name: X\ndescription: Long enough description.'
+      );
+      const result = await detectSpecFormat(tmpDir);
+      expect(result.format).toBe('speckit');
+      expect(result.detectedBy).toBe('sidecar');
+    });
+
+    it('custom dir (random .md files) → custom, low', async () => {
+      await writeFile(join(tmpDir, 'readme.md'), 'x');
+      const result = await detectSpecFormat(tmpDir);
+      expect(result.format).toBe('custom');
+      expect(result.confidence).toBe('low');
+    });
+
+    it('prd.json with valid JSON object detects as ralph (validation checks userStories)', async () => {
+      await writeFile(join(tmpDir, 'prd.json'), JSON.stringify({ other: true }));
+      const result = await detectSpecFormat(tmpDir);
+      expect(result.format).toBe('ralph');
+    });
+
+    it('prd.json invalid JSON does not detect as ralph', async () => {
+      await writeFile(join(tmpDir, 'prd.json'), 'not json');
+      await writeFile(join(tmpDir, 'readme.md'), 'x');
+      const result = await detectSpecFormat(tmpDir);
+      expect(result.format).toBe('custom');
+    });
+
+    it('legacy requires all three files', async () => {
+      await writeFile(join(tmpDir, 'spec.yaml'), 'x');
+      await writeFile(join(tmpDir, 'PROMPT.md'), 'x');
+      const result = await detectSpecFormat(tmpDir);
+      expect(result.format).not.toBe('specmarket-legacy');
+    });
+  });
+});

package/src/lib/format-detection.ts

@@ -0,0 +1,172 @@
+import { readFile, readdir, access } from 'fs/promises';
+import { join } from 'path';
+import { parse as parseYaml } from 'yaml';
+import { SIDECAR_FILENAME } from '@specmarket/shared';
+import type { FormatDetectionResult } from '@specmarket/shared';
+
+/** Check if a file exists and is readable. */
+export async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Check if a directory exists and is readable. */
+export async function directoryExists(dirPath: string): Promise<boolean> {
+  try {
+    await access(dirPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Check if directory contains any story-*.md files (BMAD pattern). */
+export async function hasStoryFiles(dir: string): Promise<boolean> {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    return entries.some(
+      (e) => e.isFile() && e.name.startsWith('story-') && e.name.endsWith('.md')
+    );
+  } catch {
+    return false;
+  }
+}
+
+/** Check if directory (non-recursive) or subdirs contain any .md files. */
+export async function hasMarkdownFiles(dir: string): Promise<boolean> {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith('.md')) return true;
+      if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+        const found = await hasMarkdownFiles(join(dir, entry.name));
+        if (found) return true;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+/** Read and parse specmarket.yaml; return spec_format if valid, else null. */
+export async function tryReadSidecar(
+  dir: string
+): Promise<{ spec_format: string } | null> {
+  const path = join(dir, SIDECAR_FILENAME);
+  if (!(await fileExists(path))) return null;
+  try {
+    const raw = await readFile(path, 'utf-8');
+    const parsed = parseYaml(raw) as unknown;
+    if (parsed && typeof parsed === 'object' && 'spec_format' in parsed) {
+      const fmt = (parsed as { spec_format: unknown }).spec_format;
+      if (typeof fmt === 'string' && fmt.length > 0) return { spec_format: fmt };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Detect spec format for a directory. Priority:
+ * 1. Sidecar specmarket.yaml with spec_format → use that value, high confidence
+ * 2. specmarket-legacy: spec.yaml + PROMPT.md + SUCCESS_CRITERIA.md
+ * 3. speckit: spec.md + (plan.md | tasks.md) + .specify/ directory
+ * 4. bmad: prd.md + (architecture.md | story-*.md)
+ * 5. ralph: prd.json with userStories[] array
+ * 6. custom: any .md files → low confidence
+ * 7. Fallback: custom, low confidence
+ */
+export async function detectSpecFormat(dir: string): Promise<FormatDetectionResult> {
+  const sidecar = await tryReadSidecar(dir);
+  if (sidecar) {
+    return {
+      format: sidecar.spec_format,
+      detectedBy: 'sidecar',
+      confidence: 'high',
+    };
+  }
+
+  const hasSpecYaml = await fileExists(join(dir, 'spec.yaml'));
+  const hasPromptMd = await fileExists(join(dir, 'PROMPT.md'));
+  const hasSuccessCriteria = await fileExists(join(dir, 'SUCCESS_CRITERIA.md'));
+  if (hasSpecYaml && hasPromptMd && hasSuccessCriteria) {
+    return {
+      format: 'specmarket-legacy',
+      detectedBy: 'heuristic',
+      confidence: 'high',
+    };
+  }
+  if (hasPromptMd && hasSuccessCriteria) {
+    return {
+      format: 'specmarket-legacy',
+      detectedBy: 'heuristic',
+      confidence: 'high',
+    };
+  }
+
+  const hasSpecMd = await fileExists(join(dir, 'spec.md'));
+  const hasPlanMd = await fileExists(join(dir, 'plan.md'));
+  const hasTasksMd = await fileExists(join(dir, 'tasks.md'));
+  if (hasSpecMd && (hasPlanMd || hasTasksMd)) {
+    return {
+      format: 'speckit',
+      detectedBy: 'heuristic',
+      confidence: 'high',
+    };
+  }
+  if (hasSpecMd) {
+    return {
+      format: 'speckit',
+      detectedBy: 'heuristic',
+      confidence: 'high',
+    };
+  }
+
+  const hasPrdMd = await fileExists(join(dir, 'prd.md'));
+  const hasArchitectureMd = await fileExists(join(dir, 'architecture.md'));
+  const storyFiles = await hasStoryFiles(dir);
+  if (hasPrdMd && (hasArchitectureMd || storyFiles)) {
+    return {
+      format: 'bmad',
+      detectedBy: 'heuristic',
+      confidence: 'high',
+    };
+  }
+
+  const prdJsonPath = join(dir, 'prd.json');
+  if (await fileExists(prdJsonPath)) {
+    try {
+      const raw = await readFile(prdJsonPath, 'utf-8');
+      const data = JSON.parse(raw) as unknown;
+      if (data && typeof data === 'object') {
+        return {
+          format: 'ralph',
+          detectedBy: 'heuristic',
+          confidence: 'high',
+        };
+      }
+    } catch {
+      // not valid JSON
+    }
+  }
+
+  if (await hasMarkdownFiles(dir)) {
+    return {
+      format: 'custom',
+      detectedBy: 'heuristic',
+      confidence: 'low',
+    };
+  }
+
+  return {
+    format: 'custom',
+    detectedBy: 'heuristic',
+    confidence: 'low',
+  };
+}