@gitpm/cli 0.1.0

package/src/__tests__/push.test.ts

@@ -0,0 +1,242 @@
+import { Command } from 'commander';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+// --- Mocks ---
+
+const mockLoadGitHubConfig = vi.fn();
+const mockExportToGitHub = vi.fn();
+const mockLoadGitLabConfig = vi.fn();
+const mockExportToGitLab = vi.fn();
+const mockResolveToken = vi.fn();
+const mockConfirm = vi.fn();
+
+vi.mock('@gitpm/sync-github', () => ({
+  loadConfig: (...args: unknown[]) => mockLoadGitHubConfig(...args),
+  exportToGitHub: (...args: unknown[]) => mockExportToGitHub(...args),
+}));
+
+vi.mock('@gitpm/sync-gitlab', () => ({
+  loadConfig: (...args: unknown[]) => mockLoadGitLabConfig(...args),
+  exportToGitLab: (...args: unknown[]) => mockExportToGitLab(...args),
+}));
+
+vi.mock('../utils/auth.js', () => ({
+  resolveToken: (...args: unknown[]) => mockResolveToken(...args),
+}));
+
+vi.mock('@inquirer/prompts', () => ({
+  confirm: (...args: unknown[]) => mockConfirm(...args),
+}));
+
+vi.mock('ora', () => ({
+  default: () => ({
+    start: vi.fn().mockReturnThis(),
+    succeed: vi.fn().mockReturnThis(),
+    fail: vi.fn().mockReturnThis(),
+    stop: vi.fn().mockReturnThis(),
+  }),
+}));
+
+let logSpy: ReturnType<typeof vi.spyOn>;
+let errorSpy: ReturnType<typeof vi.spyOn>;
+let exitSpy: ReturnType<typeof vi.spyOn>;
+
+async function run(...args: string[]) {
+  const { pushCommand } = await import('../commands/push.js');
+  const program = new Command();
+  program.option('--meta-dir <path>', 'Path to .meta directory', '.meta');
+  program.addCommand(pushCommand);
+  await program.parseAsync(['node', 'gitpm', 'push', ...args]);
+}
+
+const exportResult = {
+  created: { milestones: 1, issues: 2 },
+  updated: { milestones: 0, issues: 1 },
+  totalChanges: 4,
+};
+
+const noChangesResult = {
+  created: { milestones: 0, issues: 0 },
+  updated: { milestones: 0, issues: 0 },
+  totalChanges: 0,
+};
+
+// --- Tests ---
+
+describe('gitpm push', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.resetAllMocks();
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
+      throw new Error('process.exit');
+    }) as never);
+    mockResolveToken.mockResolvedValue('mock-token');
+    // Default: GitHub config found, GitLab not
+    mockLoadGitHubConfig.mockResolvedValue({
+      ok: true,
+      value: { repo: 'owner/repo' },
+    });
+    mockLoadGitLabConfig.mockResolvedValue({
+      ok: false,
+      error: { message: 'not found' },
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('prints preview in dry-run mode', async () => {
+    mockExportToGitHub.mockResolvedValue({ ok: true, value: exportResult });
+
+    await run('--dry-run', '--meta-dir', '/tmp/meta');
+
+    expect(mockExportToGitHub).toHaveBeenCalledWith(
+      expect.objectContaining({ dryRun: true }),
+    );
+    expect(mockConfirm).not.toHaveBeenCalled();
+    expect(exitSpy).not.toHaveBeenCalled();
+    const allOutput = logSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+    expect(allOutput).toContain('New issues:     2');
+  });
+
+  it('pushes when user confirms', async () => {
+    mockExportToGitHub
+      .mockResolvedValueOnce({ ok: true, value: exportResult }) // preview
+      .mockResolvedValueOnce({ ok: true, value: exportResult }); // actual push
+    mockConfirm.mockResolvedValue(true);
+
+    await run('--meta-dir', '/tmp/meta');
+
+    expect(mockExportToGitHub).toHaveBeenCalledTimes(2);
+    expect(mockConfirm).toHaveBeenCalled();
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('cancels push when user declines', async () => {
+    mockExportToGitHub.mockResolvedValue({ ok: true, value: exportResult });
+    mockConfirm.mockResolvedValue(false);
+
+    await run('--meta-dir', '/tmp/meta');
+
+    // Only called once for preview, not for actual push
+    expect(mockExportToGitHub).toHaveBeenCalledTimes(1);
+    const allOutput = logSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+    expect(allOutput).toContain('Push cancelled');
+  });
+
+  it('skips confirmation with --yes', async () => {
+    mockExportToGitHub
+      .mockResolvedValueOnce({ ok: true, value: exportResult })
+      .mockResolvedValueOnce({ ok: true, value: exportResult });
+
+    await run('--yes', '--meta-dir', '/tmp/meta');
+
+    expect(mockConfirm).not.toHaveBeenCalled();
+    expect(mockExportToGitHub).toHaveBeenCalledTimes(2);
+  });
+
+  it('prints nothing-to-push when totalChanges is 0', async () => {
+    mockExportToGitHub.mockResolvedValue({ ok: true, value: noChangesResult });
+
+    await run('--meta-dir', '/tmp/meta');
+
+    expect(mockConfirm).not.toHaveBeenCalled();
+    const allOutput = logSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+    expect(allOutput).toContain('Nothing to push');
+  });
+
+  it('exits with code 1 when push fails', async () => {
+    mockExportToGitHub
+      .mockResolvedValueOnce({ ok: true, value: exportResult }) // preview ok
+      .mockResolvedValueOnce({ ok: false, error: { message: 'push error' } });
+    mockConfirm.mockResolvedValue(true);
+
+    await expect(run('--meta-dir', '/tmp/meta')).rejects.toThrow(
+      'process.exit',
+    );
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it('exits with code 1 when no sync config found', async () => {
+    mockLoadGitHubConfig.mockResolvedValue({
+      ok: false,
+      error: { message: 'not found' },
+    });
+    mockLoadGitLabConfig.mockResolvedValue({
+      ok: false,
+      error: { message: 'not found' },
+    });
+
+    await expect(run('--meta-dir', '/tmp/meta')).rejects.toThrow(
+      'process.exit',
+    );
+    expect(exitSpy).toHaveBeenCalledWith(1);
+    const errOutput = errorSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+    expect(errOutput).toContain('No sync config found');
+  });
+
+  it('exits with code 1 when token resolution fails', async () => {
+    mockResolveToken.mockRejectedValue(new Error('No GitHub token found'));
+
+    await expect(run('--meta-dir', '/tmp/meta')).rejects.toThrow(
+      'process.exit',
+    );
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it('pushes to GitLab when GitLab config is found', async () => {
+    mockLoadGitHubConfig.mockResolvedValue({
+      ok: false,
+      error: { message: 'not found' },
+    });
+    mockLoadGitLabConfig.mockResolvedValue({
+      ok: true,
+      value: {
+        project: 'group/proj',
+        project_id: 42,
+        base_url: 'https://gitlab.com',
+      },
+    });
+    mockExportToGitLab.mockResolvedValue({ ok: true, value: exportResult });
+
+    await run('--dry-run', '--token', 'gl-tok', '--meta-dir', '/tmp/meta');
+
+    expect(mockExportToGitLab).toHaveBeenCalledWith(
+      expect.objectContaining({
+        token: 'gl-tok',
+        project: 'group/proj',
+        dryRun: true,
+      }),
+    );
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('exits with code 1 when GitLab token is missing', async () => {
+    const originalEnv = process.env.GITLAB_TOKEN;
+    // biome-ignore lint/performance/noDelete: must remove env var, not set to "undefined" string
+    delete process.env.GITLAB_TOKEN;
+
+    mockLoadGitHubConfig.mockResolvedValue({
+      ok: false,
+      error: { message: 'not found' },
+    });
+    mockLoadGitLabConfig.mockResolvedValue({
+      ok: true,
+      value: {
+        project: 'group/proj',
+        project_id: 42,
+        base_url: 'https://gitlab.com',
+      },
+    });
+
+    await expect(run('--meta-dir', '/tmp/meta')).rejects.toThrow(
+      'process.exit',
+    );
+    expect(exitSpy).toHaveBeenCalledWith(1);
+
+    process.env.GITLAB_TOKEN = originalEnv;
+  });
+});

package/src/__tests__/sync.test.ts

@@ -0,0 +1,264 @@
+import { Command } from 'commander';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+// --- Mocks ---
+
+const mockLoadGitHubConfig = vi.fn();
+const mockSyncWithGitHub = vi.fn();
+const mockLoadGitLabConfig = vi.fn();
+const mockSyncWithGitLab = vi.fn();
+const mockResolveToken = vi.fn();
+const mockConfirm = vi.fn();
+const mockPromptConflictResolution = vi.fn();
+
+vi.mock('@gitpm/sync-github', () => ({
+  loadConfig: (...args: unknown[]) => mockLoadGitHubConfig(...args),
+  syncWithGitHub: (...args: unknown[]) => mockSyncWithGitHub(...args),
+}));
+
+vi.mock('@gitpm/sync-gitlab', () => ({
+  loadConfig: (...args: unknown[]) => mockLoadGitLabConfig(...args),
+  syncWithGitLab: (...args: unknown[]) => mockSyncWithGitLab(...args),
+}));
+
+vi.mock('../utils/auth.js', () => ({
+  resolveToken: (...args: unknown[]) => mockResolveToken(...args),
+}));
+
+vi.mock('../utils/conflict-ui.js', () => ({
+  promptConflictResolution: (...args: unknown[]) =>
+    mockPromptConflictResolution(...args),
+}));
+
+vi.mock('@inquirer/prompts', () => ({
+  confirm: (...args: unknown[]) => mockConfirm(...args),
+}));
+
+vi.mock('ora', () => ({
+  default: () => ({
+    start: vi.fn().mockReturnThis(),
+    succeed: vi.fn().mockReturnThis(),
+    fail: vi.fn().mockReturnThis(),
+    stop: vi.fn().mockReturnThis(),
+  }),
+}));
+
+let logSpy: ReturnType<typeof vi.spyOn>;
+let errorSpy: ReturnType<typeof vi.spyOn>;
+let exitSpy: ReturnType<typeof vi.spyOn>;
+
+async function run(...args: string[]) {
+  const { syncCommand } = await import('../commands/sync.js');
+  const program = new Command();
+  program.option('--meta-dir <path>', 'Path to .meta directory', '.meta');
+  program.addCommand(syncCommand);
+  await program.parseAsync(['node', 'gitpm', 'sync', ...args]);
+}
+
+const syncResult = {
+  pushed: { milestones: 1, issues: 2 },
+  pulled: { milestones: 0, issues: 3 },
+  conflicts: [],
+  resolved: 0,
+  skipped: 0,
+};
+
+// --- Tests ---
+
+describe('gitpm sync', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.resetAllMocks();
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
+      throw new Error('process.exit');
+    }) as never);
+    mockResolveToken.mockResolvedValue('mock-token');
+    mockLoadGitHubConfig.mockResolvedValue({
+      ok: true,
+      value: { repo: 'owner/repo' },
+    });
+    mockLoadGitLabConfig.mockResolvedValue({
+      ok: false,
+      error: { message: 'not found' },
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('prints summary in dry-run mode', async () => {
+    mockSyncWithGitHub.mockResolvedValue({ ok: true, value: syncResult });
+
+    await run('--dry-run', '--meta-dir', '/tmp/meta');
+
+    expect(mockSyncWithGitHub).toHaveBeenCalledWith(
+      expect.objectContaining({ dryRun: true }),
+    );
+    expect(mockConfirm).not.toHaveBeenCalled();
+    expect(exitSpy).not.toHaveBeenCalled();
+    const allOutput = logSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+    expect(allOutput).toContain('Sync Complete');
+  });
+
+  it('syncs when user confirms', async () => {
+    mockSyncWithGitHub.mockResolvedValue({ ok: true, value: syncResult });
+    mockConfirm.mockResolvedValue(true);
+
+    await run('--meta-dir', '/tmp/meta');
+
+    expect(mockConfirm).toHaveBeenCalled();
+    expect(mockSyncWithGitHub).toHaveBeenCalled();
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('cancels sync when user declines', async () => {
+    mockConfirm.mockResolvedValue(false);
+
+    await run('--meta-dir', '/tmp/meta');
+
+    expect(mockSyncWithGitHub).not.toHaveBeenCalled();
+    const allOutput = logSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+    expect(allOutput).toContain('Sync cancelled');
+  });
+
+  it('skips confirmation with --yes', async () => {
+    mockSyncWithGitHub.mockResolvedValue({ ok: true, value: syncResult });
+
+    await run('--yes', '--meta-dir', '/tmp/meta');
+
+    expect(mockConfirm).not.toHaveBeenCalled();
+    expect(mockSyncWithGitHub).toHaveBeenCalled();
+  });
+
+  it('prompts for conflict resolution with ask strategy', async () => {
+    const conflicts = [
+      {
+        entityId: 'e1',
+        entityTitle: 'Story 1',
+        entityType: 'story',
+        field: 'status',
+        localValue: 'in_progress',
+        remoteValue: 'done',
+      },
+    ];
+    mockSyncWithGitHub.mockResolvedValue({
+      ok: true,
+      value: { ...syncResult, conflicts, resolved: 0 },
+    });
+    mockConfirm.mockResolvedValue(true);
+    mockPromptConflictResolution.mockResolvedValue([
+      { entityId: 'e1', field: 'status', pick: 'remote' },
+    ]);
+
+    await run('--strategy', 'ask', '--meta-dir', '/tmp/meta');
+
+    expect(mockPromptConflictResolution).toHaveBeenCalledWith(conflicts);
+  });
+
+  it('does not prompt for conflicts with local-wins', async () => {
+    mockSyncWithGitHub.mockResolvedValue({ ok: true, value: syncResult });
+    mockConfirm.mockResolvedValue(true);
+
+    await run('--strategy', 'local-wins', '--meta-dir', '/tmp/meta');
+
+    expect(mockPromptConflictResolution).not.toHaveBeenCalled();
+    expect(mockSyncWithGitHub).toHaveBeenCalledWith(
+      expect.objectContaining({ strategy: 'local-wins' }),
+    );
+  });
+
+  it('does not prompt for conflicts with remote-wins', async () => {
+    mockSyncWithGitHub.mockResolvedValue({ ok: true, value: syncResult });
+    mockConfirm.mockResolvedValue(true);
+
+    await run('--strategy', 'remote-wins', '--meta-dir', '/tmp/meta');
+
+    expect(mockPromptConflictResolution).not.toHaveBeenCalled();
+    expect(mockSyncWithGitHub).toHaveBeenCalledWith(
+      expect.objectContaining({ strategy: 'remote-wins' }),
+    );
+  });
+
+  it('exits with code 1 when sync fails', async () => {
+    mockSyncWithGitHub.mockResolvedValue({
+      ok: false,
+      error: { message: 'sync failed' },
+    });
+    mockConfirm.mockResolvedValue(true);
+
+    await expect(run('--meta-dir', '/tmp/meta')).rejects.toThrow(
+      'process.exit',
+    );
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it('exits with code 1 when no sync config found', async () => {
+    mockLoadGitHubConfig.mockResolvedValue({
+      ok: false,
+      error: { message: 'not found' },
+    });
+    mockLoadGitLabConfig.mockResolvedValue({
+      ok: false,
+      error: { message: 'not found' },
+    });
+
+    await expect(run('--meta-dir', '/tmp/meta')).rejects.toThrow(
+      'process.exit',
+    );
+    expect(exitSpy).toHaveBeenCalledWith(1);
+    const errOutput = errorSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+    expect(errOutput).toContain('No sync config found');
+  });
+
+  it('syncs with GitLab in dry-run mode', async () => {
+    mockLoadGitHubConfig.mockResolvedValue({
+      ok: false,
+      error: { message: 'not found' },
+    });
+    mockLoadGitLabConfig.mockResolvedValue({
+      ok: true,
+      value: {
+        project: 'group/proj',
+        project_id: 42,
+        base_url: 'https://gitlab.com',
+      },
+    });
+    mockSyncWithGitLab.mockResolvedValue({ ok: true, value: syncResult });
+
+    await run('--dry-run', '--token', 'gl-tok', '--meta-dir', '/tmp/meta');
+
+    expect(mockSyncWithGitLab).toHaveBeenCalledWith(
+      expect.objectContaining({ dryRun: true, token: 'gl-tok' }),
+    );
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('exits with code 1 when GitLab token is missing', async () => {
+    const originalEnv = process.env.GITLAB_TOKEN;
+    // biome-ignore lint/performance/noDelete: must remove env var, not set to "undefined" string
+    delete process.env.GITLAB_TOKEN;
+
+    mockLoadGitHubConfig.mockResolvedValue({
+      ok: false,
+      error: { message: 'not found' },
+    });
+    mockLoadGitLabConfig.mockResolvedValue({
+      ok: true,
+      value: {
+        project: 'group/proj',
+        project_id: 42,
+        base_url: 'https://gitlab.com',
+      },
+    });
+
+    await expect(run('--meta-dir', '/tmp/meta')).rejects.toThrow(
+      'process.exit',
+    );
+    expect(exitSpy).toHaveBeenCalledWith(1);
+
+    process.env.GITLAB_TOKEN = originalEnv;
+  });
+});

package/src/__tests__/validate.test.ts

@@ -0,0 +1,178 @@
+import { Command } from 'commander';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+// --- Mocks ---
+
+const mockParseTree = vi.fn();
+const mockResolveRefs = vi.fn();
+const mockValidateTree = vi.fn();
+
+vi.mock('@gitpm/core', () => ({
+  parseTree: (...args: unknown[]) => mockParseTree(...args),
+  resolveRefs: (...args: unknown[]) => mockResolveRefs(...args),
+  validateTree: (...args: unknown[]) => mockValidateTree(...args),
+}));
+
+let logSpy: ReturnType<typeof vi.spyOn>;
+let errorSpy: ReturnType<typeof vi.spyOn>;
+let warnSpy: ReturnType<typeof vi.spyOn>;
+let exitSpy: ReturnType<typeof vi.spyOn>;
+
+async function run(...args: string[]) {
+  const { validateCommand } = await import('../commands/validate.js');
+  const program = new Command();
+  program.option('--meta-dir <path>', 'Path to .meta directory', '.meta');
+  program.addCommand(validateCommand);
+  await program.parseAsync(['node', 'gitpm', 'validate', ...args]);
+}
+
+// --- Helpers ---
+
+function makeTree(
+  overrides?: Partial<{
+    stories: unknown[];
+    epics: unknown[];
+    milestones: unknown[];
+    roadmaps: unknown[];
+    prds: unknown[];
+    errors: unknown[];
+  }>,
+) {
+  return {
+    stories: [],
+    epics: [],
+    milestones: [],
+    roadmaps: [],
+    prds: [],
+    errors: [],
+    ...overrides,
+  };
+}
+
+// --- Tests ---
+
+describe('gitpm validate', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.resetAllMocks();
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
+      throw new Error('process.exit');
+    }) as never);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('prints success for a valid tree with no warnings', async () => {
+    const tree = makeTree({
+      stories: [{ id: 's1' }, { id: 's2' }],
+      epics: [{ id: 'e1' }],
+    });
+    mockParseTree.mockResolvedValue({ ok: true, value: tree });
+    mockResolveRefs.mockReturnValue({ ok: true, value: { resolved: true } });
+    mockValidateTree.mockReturnValue({ valid: true, errors: [], warnings: [] });
+
+    await run('--meta-dir', '/tmp/test-meta');
+
+    expect(exitSpy).not.toHaveBeenCalled();
+    const allOutput = logSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+    expect(allOutput).toContain('3 entities');
+  });
+
+  it('prints warnings but does not exit for a valid tree with warnings', async () => {
+    const tree = makeTree({ stories: [{ id: 's1' }] });
+    mockParseTree.mockResolvedValue({ ok: true, value: tree });
+    mockResolveRefs.mockReturnValue({ ok: true, value: {} });
+    mockValidateTree.mockReturnValue({
+      valid: true,
+      errors: [],
+      warnings: [
+        {
+          filePath: '/tmp/test.md',
+          entityId: 'w1',
+          code: 'WARN_01',
+          message: 'something fishy',
+        },
+      ],
+    });
+
+    await run('--meta-dir', '/tmp/test-meta');
+
+    expect(exitSpy).not.toHaveBeenCalled();
+    const warnOutput = warnSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+    expect(warnOutput).toContain('1 warning(s)');
+  });
+
+  it('exits with code 1 for an invalid tree', async () => {
+    const tree = makeTree();
+    mockParseTree.mockResolvedValue({ ok: true, value: tree });
+    mockResolveRefs.mockReturnValue({ ok: true, value: {} });
+    mockValidateTree.mockReturnValue({
+      valid: false,
+      errors: [
+        {
+          filePath: '/tmp/bad.md',
+          entityId: 'e1',
+          code: 'ERR_01',
+          message: 'bad entity',
+        },
+      ],
+      warnings: [],
+    });
+
+    await expect(run('--meta-dir', '/tmp/test-meta')).rejects.toThrow(
+      'process.exit',
+    );
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it('exits with code 1 when parseTree fails', async () => {
+    mockParseTree.mockResolvedValue({
+      ok: false,
+      error: { message: 'cannot read .meta' },
+    });
+
+    await expect(run('--meta-dir', '/tmp/test-meta')).rejects.toThrow(
+      'process.exit',
+    );
+    expect(exitSpy).toHaveBeenCalledWith(1);
+    const errOutput = errorSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+    expect(errOutput).toContain('cannot read .meta');
+  });
+
+  it('exits with code 1 when resolveRefs fails', async () => {
+    const tree = makeTree();
+    mockParseTree.mockResolvedValue({ ok: true, value: tree });
+    mockResolveRefs.mockReturnValue({
+      ok: false,
+      error: { message: 'broken ref' },
+    });
+
+    await expect(run('--meta-dir', '/tmp/test-meta')).rejects.toThrow(
+      'process.exit',
+    );
+    expect(exitSpy).toHaveBeenCalledWith(1);
+    const errOutput = errorSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+    expect(errOutput).toContain('broken ref');
+  });
+
+  it('prints parse errors from the tree', async () => {
+    const tree = makeTree({
+      errors: [
+        { filePath: '/tmp/bad-story.md', message: 'invalid frontmatter' },
+      ],
+    });
+    mockParseTree.mockResolvedValue({ ok: true, value: tree });
+    mockResolveRefs.mockReturnValue({ ok: true, value: {} });
+    mockValidateTree.mockReturnValue({ valid: true, errors: [], warnings: [] });
+
+    await run('--meta-dir', '/tmp/test-meta');
+
+    const allOutput = logSpy.mock.calls.map((c) => c.join(' ')).join('\n');
+    expect(allOutput).toContain('invalid frontmatter');
+  });
+});