bluera-knowledge 0.9.32 → 0.9.36

package/tests/fixtures/corpus/oss-repos/hono/src/utils/body.ts

@@ -13,10 +13,10 @@ type SimplifyBodyData<T> = {
   [K in keyof T]: string | File | (string | File)[] | BodyDataValueDotAll extends T[K]
     ? string | File | (string | File)[] | BodyDataValueDotAll
     : string | File | BodyDataValueDot extends T[K]
-    ? string | File | BodyDataValueDot
-    : string | File | (string | File)[] extends T[K]
-    ? string | File | (string | File)[]
-    : string | File
+      ? string | File | BodyDataValueDot
+      : string | File | (string | File)[] extends T[K]
+        ? string | File | (string | File)[]
+        : string | File
 } & {}
 
 type BodyDataValueComponent<T> =
@@ -25,16 +25,16 @@ type BodyDataValueComponent<T> =
   | (T extends { all: false }
       ? never // explicitly set to false
       : T extends { all: true } | { all: boolean }
-      ? (string | File)[] // use all option
-      : never) // without options
+        ? (string | File)[] // use all option
+        : never) // without options
 type BodyDataValueObject<T> = { [key: string]: BodyDataValueComponent<T> | BodyDataValueObject<T> }
 type BodyDataValue<T> =
   | BodyDataValueComponent<T>
   | (T extends { dot: false }
       ? never // explicitly set to false
       : T extends { dot: true } | { dot: boolean }
-      ? BodyDataValueObject<T> // use dot option
-      : never) // without options
+        ? BodyDataValueObject<T> // use dot option
+        : never) // without options
 export type BodyData<T extends Partial<ParseBodyOptions> = {}> = SimplifyBodyData<
   Record<string, BodyDataValue<T>>
 >

package/tests/fixtures/corpus/oss-repos/hono/src/utils/color.ts

@@ -18,9 +18,9 @@ export function getColorEnabled(): boolean {
     typeof Deno?.noColor === 'boolean'
       ? (Deno.noColor as boolean)
       : typeof process !== 'undefined'
-      ? // eslint-disable-next-line no-unsafe-optional-chaining
-        'NO_COLOR' in process?.env
-      : false
+        ? // eslint-disable-next-line no-unsafe-optional-chaining
+          'NO_COLOR' in process?.env
+        : false
 
   return !isNoColor
 }

package/tests/fixtures/corpus/oss-repos/hono/src/utils/cookie.ts

@@ -31,8 +31,8 @@ export type CookiePrefixOptions = 'host' | 'secure'
 export type CookieConstraint<Name> = Name extends `__Secure-${string}`
   ? CookieOptions & SecureCookieConstraint
   : Name extends `__Host-${string}`
-  ? CookieOptions & HostCookieConstraint
-  : CookieOptions
+    ? CookieOptions & HostCookieConstraint
+    : CookieOptions
 
 const algorithm = { name: 'HMAC', hash: 'SHA-256' }
 

package/tests/fixtures/corpus/oss-repos/hono/src/utils/encode.ts

@@ -4,11 +4,11 @@
  */
 
 export const decodeBase64Url = (str: string): Uint8Array => {
-  return decodeBase64(str.replace(/_|-/g, (m) => ({ _: '/', '-': '+' }[m] ?? m)))
+  return decodeBase64(str.replace(/_|-/g, (m) => ({ _: '/', '-': '+' })[m] ?? m))
 }
 
 export const encodeBase64Url = (buf: ArrayBufferLike): string =>
-  encodeBase64(buf).replace(/\/|\+/g, (m) => ({ '/': '_', '+': '-' }[m] ?? m))
+  encodeBase64(buf).replace(/\/|\+/g, (m) => ({ '/': '_', '+': '-' })[m] ?? m)
 
 // This approach is written in MDN.
 // btoa does not support utf-8 characters. So we need a little bit hack.

package/tests/fixtures/corpus/oss-repos/hono/src/utils/types.ts

@@ -5,9 +5,8 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 export type Expect<T extends true> = T
-export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
-  ? true
-  : false
+export type Equal<X, Y> =
+  (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false
 export type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true
 
 export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
@@ -16,11 +15,8 @@ export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) ex
   ? I
   : never
 
-export type RemoveBlankRecord<T> = T extends Record<infer K, unknown>
-  ? K extends string
-    ? T
-    : never
-  : never
+export type RemoveBlankRecord<T> =
+  T extends Record<infer K, unknown> ? (K extends string ? T : never) : never
 
 export type IfAnyThenEmptyObject<T> = 0 extends 1 & T ? {} : T
 
@@ -46,29 +42,31 @@ export type JSONParsed<T> = T extends { toJSON(): infer J }
   ? (() => J) extends () => JSONPrimitive
     ? J
     : (() => J) extends () => { toJSON(): unknown }
-    ? {}
-    : JSONParsed<J>
+      ? {}
+      : JSONParsed<J>
   : T extends JSONPrimitive
-  ? T
-  : T extends InvalidJSONValue
-  ? never
-  : T extends []
-  ? []
-  : T extends readonly [infer R, ...infer U]
-  ? [JSONParsed<InvalidToNull<R>>, ...JSONParsed<U>]
-  : T extends Array<infer U>
-  ? Array<JSONParsed<InvalidToNull<U>>>
-  : T extends ReadonlyArray<infer U>
-  ? ReadonlyArray<JSONParsed<InvalidToNull<U>>>
-  : T extends Set<unknown> | Map<unknown, unknown>
-  ? {}
-  : T extends object
-  ? {
-      [K in keyof OmitSymbolKeys<T> as IsInvalid<T[K]> extends true
-        ? never
-        : K]: boolean extends IsInvalid<T[K]> ? JSONParsed<T[K]> | undefined : JSONParsed<T[K]>
-    }
-  : never
+    ? T
+    : T extends InvalidJSONValue
+      ? never
+      : T extends []
+        ? []
+        : T extends readonly [infer R, ...infer U]
+          ? [JSONParsed<InvalidToNull<R>>, ...JSONParsed<U>]
+          : T extends Array<infer U>
+            ? Array<JSONParsed<InvalidToNull<U>>>
+            : T extends ReadonlyArray<infer U>
+              ? ReadonlyArray<JSONParsed<InvalidToNull<U>>>
+              : T extends Set<unknown> | Map<unknown, unknown>
+                ? {}
+                : T extends object
+                  ? {
+                      [K in keyof OmitSymbolKeys<T> as IsInvalid<T[K]> extends true
+                        ? never
+                        : K]: boolean extends IsInvalid<T[K]>
+                        ? JSONParsed<T[K]> | undefined
+                        : JSONParsed<T[K]>
+                    }
+                  : never
 
 /**
  * Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
@@ -92,9 +90,8 @@ export type RequiredKeysOf<BaseType extends object> = Exclude<
   undefined
 >
 
-export type HasRequiredKeys<BaseType extends object> = RequiredKeysOf<BaseType> extends never
-  ? false
-  : true
+export type HasRequiredKeys<BaseType extends object> =
+  RequiredKeysOf<BaseType> extends never ? false : true
 
 export type IsAny<T> = boolean extends (T extends never ? true : false) ? true : false
 

package/tests/fixtures/corpus/oss-repos/hono/src/validator/validator.ts

@@ -14,7 +14,7 @@ export type ValidationFunction<
   InputType,
   OutputType,
   E extends Env = {},
-  P extends string = string
+  P extends string = string,
 > = (
   value: InputType,
   c: Context<E, P>
@@ -55,7 +55,7 @@ export const validator = <
     out: { [K in U]: OutputTypeExcludeResponseType }
   },
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  E extends Env = any
+  E extends Env = any,
 >(
   target: U,
   validationFunc: ValidationFunction<

package/tests/fixtures/test-server.ts

@@ -171,8 +171,9 @@ export class TestHTMLServer {
     // Page with many links (for testing link extraction)
     if (url === '/many-links') {
       res.writeHead(200, { 'Content-Type': 'text/html' });
-      const links = Array.from({ length: 20 }, (_, i) =>
-        `<a href="/link${String(i)}">Link ${String(i)}</a>`
+      const links = Array.from(
+        { length: 20 },
+        (_, i) => `<a href="/link${String(i)}">Link ${String(i)}</a>`
       ).join('\n');
       res.end(`
         <!DOCTYPE html>

package/tests/helpers/performance-metrics.ts

@@ -108,9 +108,7 @@ export function measureSync<T>(
  * @param measurements - Array of measurements
  * @returns Statistical summary
  */
-export function calculateStats(
-  measurements: PerformanceMeasurement[]
-): PerformanceStats {
+export function calculateStats(measurements: PerformanceMeasurement[]): PerformanceStats {
   if (measurements.length === 0) {
     return {
       count: 0,
@@ -131,8 +129,7 @@ export function calculateStats(
 
   // Calculate standard deviation
   const squaredDiffs = durations.map((d) => Math.pow(d - mean, 2));
-  const avgSquaredDiff =
-    squaredDiffs.reduce((sum, d) => sum + d, 0) / durations.length;
+  const avgSquaredDiff = squaredDiffs.reduce((sum, d) => sum + d, 0) / durations.length;
   const stdDev = Math.sqrt(avgSquaredDiff);
 
   return {
@@ -173,10 +170,7 @@ function percentile(sortedValues: number[], p: number): number {
  * @param measurement - Measurement to check
  * @param maxDuration - Maximum acceptable duration in ms
  */
-export function assertDuration(
-  measurement: PerformanceMeasurement,
-  maxDuration: number
-): void {
+export function assertDuration(measurement: PerformanceMeasurement, maxDuration: number): void {
   if (measurement.duration > maxDuration) {
     throw new Error(
       `${measurement.name} took ${measurement.duration.toFixed(2)}ms, ` +
@@ -203,27 +197,19 @@ export function assertPerformanceTargets(
   const failures: string[] = [];
 
   if (targets.maxMean !== undefined && stats.mean > targets.maxMean) {
-    failures.push(
-      `Mean ${stats.mean.toFixed(2)}ms exceeds target ${targets.maxMean}ms`
-    );
+    failures.push(`Mean ${stats.mean.toFixed(2)}ms exceeds target ${targets.maxMean}ms`);
   }
 
   if (targets.maxP95 !== undefined && stats.p95 > targets.maxP95) {
-    failures.push(
-      `P95 ${stats.p95.toFixed(2)}ms exceeds target ${targets.maxP95}ms`
-    );
+    failures.push(`P95 ${stats.p95.toFixed(2)}ms exceeds target ${targets.maxP95}ms`);
   }
 
   if (targets.maxP99 !== undefined && stats.p99 > targets.maxP99) {
-    failures.push(
-      `P99 ${stats.p99.toFixed(2)}ms exceeds target ${targets.maxP99}ms`
-    );
+    failures.push(`P99 ${stats.p99.toFixed(2)}ms exceeds target ${targets.maxP99}ms`);
   }
 
   if (targets.maxMax !== undefined && stats.max > targets.maxMax) {
-    failures.push(
-      `Max ${stats.max.toFixed(2)}ms exceeds target ${targets.maxMax}ms`
-    );
+    failures.push(`Max ${stats.max.toFixed(2)}ms exceeds target ${targets.maxMax}ms`);
   }
 
   if (failures.length > 0) {
@@ -263,10 +249,7 @@ export class Benchmark {
   /**
    * Run multiple iterations
    */
-  async runIterations<T>(
-    iterations: number,
-    fn: () => Promise<T>
-  ): Promise<T[]> {
+  async runIterations<T>(iterations: number, fn: () => Promise<T>): Promise<T[]> {
     const results: T[] = [];
     for (let i = 0; i < iterations; i++) {
       results.push(await this.run(fn));

package/tests/helpers/search-relevance.ts

@@ -71,7 +71,9 @@ export function parseSearchOutput(output: string): SearchResult[] {
       const headerContent = headerMatch[3].trim();
 
       // Check if this is new format (contains type prefix like "function:", "class:", etc.)
-      const typeMatch = headerContent.match(/^(function|class|interface|type|const|documentation):\s+(.+)$/);
+      const typeMatch = headerContent.match(
+        /^(function|class|interface|type|const|documentation):\s+(.+)$/
+      );
       if (typeMatch) {
         // New format - next line should contain the location
         currentResult = {
@@ -140,18 +142,13 @@ export function parseSearchOutput(output: string): SearchResult[] {
  * @param expected - Expected match criteria
  * @returns true if result matches all criteria
  */
-export function matchesExpectation(
-  result: SearchResult,
-  expected: ExpectedMatch
-): boolean {
+export function matchesExpectation(result: SearchResult, expected: ExpectedMatch): boolean {
   const contentLower = result.content.toLowerCase();
   const sourceLower = result.source.toLowerCase();
 
   // Check keywords (any match)
   if (expected.keywords && expected.keywords.length > 0) {
-    const hasKeyword = expected.keywords.some((kw) =>
-      contentLower.includes(kw.toLowerCase())
-    );
+    const hasKeyword = expected.keywords.some((kw) => contentLower.includes(kw.toLowerCase()));
     if (!hasKeyword) return false;
   }
 
@@ -190,16 +187,11 @@ export function matchesExpectation(
  * @param expected - Expected match criteria
  * @returns The first matching result, or throws if none found
  */
-export function assertHasMatch(
-  results: SearchResult[],
-  expected: ExpectedMatch
-): SearchResult {
+export function assertHasMatch(results: SearchResult[], expected: ExpectedMatch): SearchResult {
   const match = results.find((r) => matchesExpectation(r, expected));
   if (!match) {
     const criteria = JSON.stringify(expected, null, 2);
-    const resultsSummary = results
-      .map((r) => `  ${r.rank}. [${r.score}] ${r.source}`)
-      .join('\n');
+    const resultsSummary = results.map((r) => `  ${r.rank}. [${r.score}] ${r.source}`).join('\n');
     throw new Error(
       `No result matches expected criteria:\n${criteria}\n\nResults:\n${resultsSummary}`
     );
@@ -256,9 +248,7 @@ export function calculateRelevanceMetrics(
     relevantCount: relevant.length,
     totalCount: results.length,
     averageScore:
-      results.length > 0
-        ? results.reduce((sum, r) => sum + r.score, 0) / results.length
-        : 0,
+      results.length > 0 ? results.reduce((sum, r) => sum + r.score, 0) / results.length : 0,
     topScore: results.length > 0 ? results[0].score : 0,
   };
 }
@@ -298,10 +288,7 @@ export function compareRelevance(
  * @param results - Search results
  * @param minScore - Minimum acceptable score
  */
-export function assertMinimumScores(
-  results: SearchResult[],
-  minScore: number
-): void {
+export function assertMinimumScores(results: SearchResult[], minScore: number): void {
   for (const result of results) {
     if (result.score < minScore) {
       throw new Error(
@@ -330,52 +317,10 @@ export function assertProperOrdering(results: SearchResult[]): void {
  * Common keyword sets for testing
  */
 export const CommonKeywords = {
-  AUTHENTICATION: [
-    'auth',
-    'login',
-    'jwt',
-    'token',
-    'password',
-    'session',
-    'oauth',
-    'credential',
-  ],
-  API: [
-    'endpoint',
-    'request',
-    'response',
-    'rest',
-    'http',
-    'route',
-    'controller',
-    'middleware',
-  ],
-  DATABASE: [
-    'query',
-    'database',
-    'repository',
-    'entity',
-    'model',
-    'schema',
-    'sql',
-    'orm',
-  ],
-  TYPESCRIPT: [
-    'typescript',
-    'type',
-    'interface',
-    'generic',
-    'compiler',
-    'tsc',
-  ],
+  AUTHENTICATION: ['auth', 'login', 'jwt', 'token', 'password', 'session', 'oauth', 'credential'],
+  API: ['endpoint', 'request', 'response', 'rest', 'http', 'route', 'controller', 'middleware'],
+  DATABASE: ['query', 'database', 'repository', 'entity', 'model', 'schema', 'sql', 'orm'],
+  TYPESCRIPT: ['typescript', 'type', 'interface', 'generic', 'compiler', 'tsc'],
   REACT: ['react', 'component', 'jsx', 'hook', 'state', 'props', 'render'],
-  ERROR_HANDLING: [
-    'error',
-    'exception',
-    'catch',
-    'throw',
-    'try',
-    'handler',
-    'validation',
-  ],
+  ERROR_HANDLING: ['error', 'exception', 'catch', 'throw', 'try', 'handler', 'validation'],
 } as const;

package/tests/integration/cli-consistency.test.ts

@@ -50,7 +50,10 @@ describe('CLI Consistency', () => {
    * Helper to run CLI and capture output + exit code
    * Properly handles quoted arguments
    */
-  const runCli = (args: string, options: { expectError?: boolean; stdin?: string } = {}): {
+  const runCli = (
+    args: string,
+    options: { expectError?: boolean; stdin?: string } = {}
+  ): {
     stdout: string;
     stderr: string;
     exitCode: number;
@@ -107,7 +110,7 @@ describe('CLI Consistency', () => {
     it('returns exit code 0 on success', () => {
       const result = runCli('store list');
       expect(result.exitCode).toBe(0);
-    });
+    }, 15000);
 
     it('returns non-zero exit code when store not found', () => {
       const result = runCli('store info nonexistent-store');
@@ -133,7 +136,6 @@ describe('CLI Consistency', () => {
       expect(result.exitCode).not.toBe(0);
       expect(result.stderr).toContain('Error: Store not found');
     });
-
   });
 
   describe('--format json Support', () => {
@@ -262,7 +264,7 @@ describe('CLI Consistency', () => {
       const result = runCli('store delete delete-force-store --force');
       expect(result.exitCode).toBe(0);
       expect(result.stdout).toContain('Deleted');
-    });
+    }, 15000);
 
     it('accepts -y as alias for --force', () => {
       try {
@@ -291,6 +293,5 @@ describe('CLI Consistency', () => {
       expect(result.stdout).not.toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
       expect(result.exitCode).toBe(0);
     }, 120000);
-
   });
 });

package/tests/integration/python-bridge.test.ts

@@ -33,6 +33,18 @@ describe('Python Bridge Integration Tests', () => {
       expect(result.pages.length).toBeGreaterThan(0);
     }, 30000);
 
+    it('stop() waits for process to actually exit', async () => {
+      // Make a request to ensure process is running
+      await bridge.crawl(baseUrl);
+
+      // Stop should wait for process exit
+      await bridge.stop();
+
+      // After stop() resolves, the process should be fully terminated
+      // Calling stop() again should be a no-op (process already null)
+      await bridge.stop(); // Should not hang or error
+    }, 30000);
+
     it('can create new bridge after stopping', async () => {
       // Stop the current bridge
       await bridge.stop();
@@ -143,9 +155,7 @@ describe('Python Bridge Integration Tests', () => {
   describe('Error Handling', () => {
     it('handles invalid URLs gracefully', async () => {
       // Python worker should handle invalid URLs and return error
-      await expect(
-        bridge.crawl('not-a-valid-url')
-      ).rejects.toThrow();
+      await expect(bridge.crawl('not-a-valid-url')).rejects.toThrow();
     }, 30000);
 
     it('handles 404 pages', async () => {

package/tests/mcp/server.test.ts

@@ -5,7 +5,7 @@ describe('MCP Server', () => {
   it('should create server with search tool', () => {
     const server = createMCPServer({
       dataDir: '/tmp/test',
-      config: undefined
+      config: undefined,
     });
 
     expect(server).toBeDefined();

package/tests/services/code-unit.service.test.ts

@@ -26,6 +26,54 @@ export function parseToken(token: string): object {
     expect(unit.endLine).toBe(5);
   });
 
+  it('should extract function with Promise return type', () => {
+    const code = `
+export async function getData(id: string): Promise<User> {
+  return await db.find(id);
+}
+`;
+
+    const service = new CodeUnitService();
+    const unit = service.extractCodeUnit(code, 'getData', 'typescript');
+
+    expect(unit).toBeDefined();
+    expect(unit.type).toBe('function');
+    expect(unit.name).toBe('getData');
+    // Should include the generic type
+    expect(unit.signature).toContain('getData(id: string)');
+    expect(unit.signature).toContain('Promise<User>');
+  });
+
+  it('should extract function with array return type', () => {
+    const code = `
+export function getUsers(): User[] {
+  return users;
+}
+`;
+
+    const service = new CodeUnitService();
+    const unit = service.extractCodeUnit(code, 'getUsers', 'typescript');
+
+    expect(unit).toBeDefined();
+    expect(unit.signature).toContain('getUsers()');
+    expect(unit.signature).toContain('User[]');
+  });
+
+  it('should extract function with union return type', () => {
+    const code = `
+export function findUser(id: string): User | null {
+  return users.find(u => u.id === id) || null;
+}
+`;
+
+    const service = new CodeUnitService();
+    const unit = service.extractCodeUnit(code, 'findUser', 'typescript');
+
+    expect(unit).toBeDefined();
+    expect(unit.signature).toContain('findUser(id: string)');
+    expect(unit.signature).toContain('User | null');
+  });
+
   it('should extract class with methods', () => {
     const code = `
 export class UserService {

package/tests/services/job.service.test.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { JobService } from '../../src/services/job.service.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+describe('JobService', () => {
+  let jobService: JobService;
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'job-service-test-'));
+    jobService = new JobService(tempDir);
+  });
+
+  afterEach(() => {
+    // Clean up temp directory
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('cancelJob', () => {
+    it('handles invalid PID in PID file gracefully', () => {
+      // Create a job
+      const job = jobService.createJob({
+        type: 'index',
+        message: 'Test job',
+      });
+
+      // Write an invalid PID to the PID file
+      const pidFile = path.join(tempDir, 'jobs', `${job.id}.pid`);
+      fs.writeFileSync(pidFile, 'not-a-number', 'utf-8');
+
+      // Cancel should succeed without throwing
+      const result = jobService.cancelJob(job.id);
+      expect(result.success).toBe(true);
+
+      // Job should be marked as cancelled
+      const cancelled = jobService.getJob(job.id);
+      expect(cancelled?.status).toBe('cancelled');
+    });
+
+    it('handles NaN PID gracefully', () => {
+      // Create a job
+      const job = jobService.createJob({
+        type: 'index',
+        message: 'Test job',
+      });
+
+      // Write NaN-producing content to PID file
+      const pidFile = path.join(tempDir, 'jobs', `${job.id}.pid`);
+      fs.writeFileSync(pidFile, '', 'utf-8');
+
+      // Cancel should succeed without throwing
+      const result = jobService.cancelJob(job.id);
+      expect(result.success).toBe(true);
+    });
+
+    it('handles negative PID gracefully', () => {
+      // Create a job
+      const job = jobService.createJob({
+        type: 'index',
+        message: 'Test job',
+      });
+
+      // Write negative PID to file (invalid)
+      const pidFile = path.join(tempDir, 'jobs', `${job.id}.pid`);
+      fs.writeFileSync(pidFile, '-1', 'utf-8');
+
+      // Cancel should succeed without throwing
+      const result = jobService.cancelJob(job.id);
+      expect(result.success).toBe(true);
+    });
+
+    it('handles zero PID gracefully', () => {
+      // Create a job
+      const job = jobService.createJob({
+        type: 'index',
+        message: 'Test job',
+      });
+
+      // Write zero PID to file (invalid - would kill current process group)
+      const pidFile = path.join(tempDir, 'jobs', `${job.id}.pid`);
+      fs.writeFileSync(pidFile, '0', 'utf-8');
+
+      // Cancel should succeed without throwing or killing process group
+      const result = jobService.cancelJob(job.id);
+      expect(result.success).toBe(true);
+    });
+
+    it('handles non-existent process gracefully', () => {
+      // Create a job
+      const job = jobService.createJob({
+        type: 'index',
+        message: 'Test job',
+      });
+
+      // Write a PID that almost certainly doesn't exist
+      const pidFile = path.join(tempDir, 'jobs', `${job.id}.pid`);
+      fs.writeFileSync(pidFile, '999999999', 'utf-8');
+
+      // Cancel should succeed without throwing
+      const result = jobService.cancelJob(job.id);
+      expect(result.success).toBe(true);
+    });
+
+    it('cleans up PID file after cancel', () => {
+      // Create a job
+      const job = jobService.createJob({
+        type: 'index',
+        message: 'Test job',
+      });
+
+      // Write a valid-looking PID
+      const pidFile = path.join(tempDir, 'jobs', `${job.id}.pid`);
+      fs.writeFileSync(pidFile, '12345', 'utf-8');
+
+      // Cancel the job
+      jobService.cancelJob(job.id);
+
+      // PID file should be deleted
+      expect(fs.existsSync(pidFile)).toBe(false);
+    });
+  });
+});