test: close coverage gaps to 100% lines / ~97% branches (GG-44)

The previously-uncovered lines were untested, not unreachable. Add the missing
tests and mark the genuinely-untestable spots explicitly:

- cliArgs: --endpoint / --language parsing
- prompt: cleanModelOutput('') early return
- providers/index: export + unit-test unavailableMessage (all 3 branches),
  resolveProvider local branch + language-hint apple rebuild
- providers/cli: available probe, spawn error, empty-output (hint/no-hint),
  bare exit code
- providers/local: abort/timeout, non-OK status, empty response, /models
  non-OK, env-endpoint resolution, malformed-response guards
- releaseNotes: default stderr warn sink, default cwd, non-Error formatting,
  singular/plural noun
- template: non-ENOENT read error re-throw
- git (integration): empty untracked file, all-empty categories, default cwd
- apple: detectSystemLanguage catch (simulated small-ICU Intl throw)

v8-ignore (with reasons) the genuine live-I/O sinks — anthropicApi defaultRun,
local defaultFetch — and the defensive git untrackedDiff fallbacks that real
git never reaches. Raise the vitest floors (80/75/72/80 → 98/95/97/99) to lock
the gains, and sync the analyze-code-quality skill's quoted thresholds.

Tests 159 → 188. Coverage: lines 94.18 → 100, statements 92.89 → 99.63,
functions 89.47 → 98.91, branches 87.61 → 97.11.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: 2 people

.claude/skills/analyze-code-quality/SKILL.md

@@ -14,8 +14,8 @@ report.
    npm test
    ```
    Report total tests, pass/fail, and coverage per file. The thresholds in
-   `vitest.config.ts` are the floor — currently **statements 80 / branches 75 /
-   functions 72 / lines 80**, with `src/cli.ts` excluded as the thin bin. Flag
+   `vitest.config.ts` are the floor — currently **statements 98 / branches 95 /
+   functions 97 / lines 99**, with `src/cli.ts` excluded as the thin bin. Flag
    any file that drags the suite toward those floors. The real-I/O provider paths
    (`anthropicApi.ts`, `apple.ts`, `local.ts`) are expected to show lower line
    coverage because their network/subprocess calls aren't exercised live; what

src/git.ts

@@ -119,6 +119,10 @@ async function untrackedDiff(path: string, cwd: string): Promise<string> {
       ['diff', '--no-color', '--no-index', '--', '/dev/null', path],
       { cwd, maxBuffer: GIT_MAX_BUFFER },
     );
+    // Defensive: `git diff --no-index /dev/null <file>` always reports a new
+    // file (mode/index differ, even for an empty file) and so always exits
+    // non-zero — the diff arrives via the catch below, never here.
+    /* v8 ignore next */
     return stdout;
   } catch (err: unknown) {
     // `git diff --no-index` exits 1 whenever the files differ — which is always
@@ -127,6 +131,9 @@ async function untrackedDiff(path: string, cwd: string): Promise<string> {
       const { stdout } = err as { stdout?: unknown };
       if (typeof stdout === 'string') return stdout;
     }
+    // Defensive: real `git diff --no-index` always attaches the diff to the
+    // rejected call's `stdout`, so this fallback is effectively unreachable.
+    /* v8 ignore next */
     return `new file: ${path}`;
   }
 }

src/providers/anthropicApi.ts

@@ -51,6 +51,9 @@ export interface AnthropicApiProviderConfig {
  * for this model. The SDK is imported **lazily** so `--no-ai` and the CLI
  * provider don't pay the load cost.
  */
+/* v8 ignore start -- thin real-SDK adapter: hits the live Anthropic API, so it
+   is not exercised in unit tests; the provider's logic is covered via an
+   injected `run` (see createAnthropicApiProvider tests). */
 const defaultRun: AnthropicRunFn = async ({ model, maxTokens, system, prompt }) => {
   const { default: Anthropic } = await import('@anthropic-ai/sdk');
   const client = new Anthropic();
@@ -71,6 +74,7 @@ const defaultRun: AnthropicRunFn = async ({ model, maxTokens, system, prompt })
     ),
   };
 };
+/* v8 ignore stop */
 
 /**
  * Build an {@link AIProvider} backed by the **Anthropic Messages API** (official

src/providers/index.ts

@@ -77,7 +77,16 @@ export interface ResolveProviderOptions {
   language?: string;
 }
 
-function unavailableMessage(name: string, endpoint?: string): string {
+/**
+ * Build the actionable "provider unavailable" message for a resolved provider,
+ * naming the concrete fix (set the key, start a local server, or install the
+ * CLI). Exported for unit testing.
+ *
+ * @param name - The provider id (e.g. `anthropic-api`, `local`, `claude-cli`).
+ * @param endpoint - The local endpoint, included in the `local` message when set.
+ * @returns The user-facing unavailability message.
+ */
+export function unavailableMessage(name: string, endpoint?: string): string {
   if (name === 'anthropic-api') {
     return 'The anthropic-api provider is unavailable: set ANTHROPIC_API_KEY.';
   }

src/providers/local.ts

@@ -21,6 +21,7 @@ export type FetchLike = (
   init?: FetchInit,
 ) => Promise<{ ok: boolean; status: number; json: () => Promise<unknown> }>;
 
+/* v8 ignore next -- thin wrapper over the global fetch; tests inject fetchImpl. */
 const defaultFetch: FetchLike = (url, init) => fetch(url, init);
 
 /** Config captured by {@link createLocalProvider}. */

tests/apple.test.ts

@@ -160,4 +160,17 @@ describe('detectSystemLanguage', () => {
       expect(lang.length).toBeGreaterThan(0);
     }
   });
+
+  it('returns undefined when the Intl runtime throws (e.g. a small-ICU build)', () => {
+    const original = Intl.DateTimeFormat;
+    // Simulate a Node build without full ICU, where Intl construction throws.
+    (Intl as { DateTimeFormat: unknown }).DateTimeFormat = () => {
+      throw new Error('no ICU');
+    };
+    try {
+      expect(detectSystemLanguage()).toBeUndefined();
+    } finally {
+      (Intl as { DateTimeFormat: unknown }).DateTimeFormat = original;
+    }
+  });
 });

tests/cliArgs.test.ts

@@ -39,6 +39,12 @@ describe('parseArgs', () => {
     expect(parseArgs(['--provider', 'claude-cli']).provider).toBe('claude-cli');
   });
 
+  it('parses --endpoint and --language', () => {
+    const args = parseArgs(['--endpoint', 'http://localhost:11434/v1', '--language', 'French']);
+    expect(args.endpoint).toBe('http://localhost:11434/v1');
+    expect(args.language).toBe('French');
+  });
+
   it('parses a valid --max-tokens', () => {
     expect(parseArgs(['--max-tokens', '8000']).maxTokens).toBe(8000);
   });

tests/integration.test.ts

@@ -82,6 +82,14 @@ describe('git + orchestration integration', () => {
     expect(notes).not.toContain('bravo');
   });
 
+  it('generateReleaseNotes resolves the range itself when none is given', async () => {
+    // No `range`/`from`/`to`: it must auto-resolve (untagged repo → full history)
+    // rather than requiring an explicit range.
+    const notes = await generateReleaseNotes({ ai: false, cwd: untagged });
+    expect(notes).toContain('## Features');
+    expect(notes).toContain('only commit');
+  });
+
   it('generateReleaseNotes reports an empty range cleanly', async () => {
     const notes = await generateReleaseNotes({ range: 'HEAD..HEAD', ai: false, cwd: tagged });
     expect(notes.trim()).toBe('_No changes in `HEAD..HEAD`._');
@@ -116,6 +124,10 @@ describe('working-tree changes integration', () => {
 
     // Untracked: a new file never added.
     writeFileSync(join(repo, 'untracked.txt'), 'brand new\n');
+
+    // Untracked but empty: git still reports it as a new file, so the diff must
+    // surface it even with zero content.
+    writeFileSync(join(repo, 'empty.txt'), '');
   });
 
   afterAll(() => {
@@ -133,6 +145,7 @@ describe('working-tree changes integration', () => {
     expect(wc.staged).toContain('staged.txt');
     expect(wc.unstaged).toContain('tracked.txt');
     expect(wc.untracked).toContain('untracked.txt');
+    expect(wc.untracked).toContain('empty.txt');
     expect(wc.diff).toContain('### Staged changes');
     expect(wc.diff).toContain('### Unstaged changes');
     expect(wc.diff).toContain('### New (untracked) files');
@@ -146,6 +159,31 @@ describe('working-tree changes integration', () => {
     expect(wc.untracked).toEqual([]);
   });
 
+  it('readWorkingChanges emits no sections when every requested category is empty', async () => {
+    const clean = initRepo();
+    try {
+      writeFileSync(join(clean, 'committed.txt'), 'x\n');
+      git(clean, 'add', 'committed.txt');
+      commit(clean, 'feat: only commit');
+      const wc = await readWorkingChanges({
+        cwd: clean,
+        staged: true,
+        unstaged: true,
+        untracked: true,
+      });
+      expect(wc.isEmpty).toBe(true);
+      expect(wc.diff).toBe('');
+    } finally {
+      rmSync(clean, { recursive: true, force: true });
+    }
+  });
+
+  it('readWorkingChanges defaults cwd and returns empty when nothing is requested', async () => {
+    // No options: cwd falls back to process.cwd() and no git category runs.
+    const wc = await readWorkingChanges();
+    expect(wc).toMatchObject({ staged: [], unstaged: [], untracked: [], isEmpty: true });
+  });
+
   it('generateReleaseNotes (--no-ai) renders an Uncommitted changes section', async () => {
     const notes = await generateReleaseNotes({
       cwd: repo,

tests/prompt.test.ts

@@ -150,6 +150,11 @@ describe('cleanModelOutput (notes / template)', () => {
   it('leaves the _No changes_ sentinel (no heading) untouched', () => {
     expect(cleanModelOutput('_No user-facing changes._', 'notes')).toBe('_No user-facing changes._');
   });
+
+  it('returns empty for blank/whitespace-only output', () => {
+    expect(cleanModelOutput('', 'notes')).toBe('');
+    expect(cleanModelOutput('   \n  ', 'notes')).toBe('');
+  });
 });
 
 describe('cleanModelOutput (commit)', () => {