bluera-knowledge 0.9.21

package/src/plugin/commands.ts

@@ -0,0 +1,257 @@
+import { createServices } from '../services/index.js';
+import { extractRepoName } from './git-clone.js';
+import { DependencyUsageAnalyzer } from '../analysis/dependency-usage-analyzer.js';
+import { RepoUrlResolver } from '../analysis/repo-url-resolver.js';
+import ora from 'ora';
+
+export async function handleSearch(args: {
+  query: string;
+  stores?: string;
+  limit?: string;
+}): Promise<void> {
+  // PWD is set by Claude Code to user's project directory
+  const services = await createServices(undefined, undefined, process.env['PWD']);
+  const storeNames = args.stores?.split(',').map((s: string) => s.trim());
+
+  const allStores = await services.store.list();
+  const targetStores = storeNames !== undefined
+    ? allStores.filter((s) => storeNames.includes(s.name))
+    : allStores;
+
+  if (targetStores.length === 0) {
+    console.error('No stores found to search');
+    process.exit(1);
+  }
+
+  // Initialize stores
+  for (const store of targetStores) {
+    await services.lance.initialize(store.id);
+  }
+
+  const results = await services.search.search({
+    query: args.query,
+    stores: targetStores.map((s) => s.id),
+    mode: 'hybrid',
+    limit: parseInt(args.limit ?? '10', 10),
+    detail: 'contextual'
+  });
+
+  console.log(`Found ${String(results.totalResults)} results:\n`);
+  for (const r of results.results) {
+    if (r.summary !== undefined) {
+      console.log(`Score: ${r.score.toFixed(2)} - ${r.summary.location}`);
+      console.log(r.summary.purpose);
+    }
+    console.log('---');
+  }
+}
+
+export async function handleAddRepo(args: {
+  url: string;
+  name?: string;
+  branch?: string;
+}): Promise<void> {
+  // PWD is set by Claude Code to user's project directory
+  const services = await createServices(undefined, undefined, process.env['PWD']);
+  const storeName = args.name ?? extractRepoName(args.url);
+
+  console.log(`Cloning ${args.url}...`);
+
+  const result = await services.store.create({
+    name: storeName,
+    type: 'repo',
+    url: args.url,
+    ...(args.branch !== undefined ? { branch: args.branch } : {})
+  });
+
+  if (!result.success) {
+    console.error(`Error: ${result.error.message}`);
+    process.exit(1);
+  }
+
+  console.log(`Created store: ${storeName} (${result.data.id})`);
+  if ('path' in result.data) {
+    console.log(`Location: ${result.data.path}`);
+  }
+
+  // Auto-index
+  console.log('\nIndexing...');
+  const indexResult = await services.index.indexStore(result.data);
+
+  if (indexResult.success) {
+    console.log(`Indexed ${String(indexResult.data.documentsIndexed)} files`);
+  } else {
+    console.error(`Indexing failed: ${indexResult.error.message}`);
+  }
+}
+
+export async function handleAddFolder(args: {
+  path: string;
+  name?: string;
+}): Promise<void> {
+  // PWD is set by Claude Code to user's project directory
+  const services = await createServices(undefined, undefined, process.env['PWD']);
+  const { basename } = await import('node:path');
+  const storeName = args.name ?? basename(args.path);
+
+  console.log(`Adding folder: ${args.path}...`);
+
+  const result = await services.store.create({
+    name: storeName,
+    type: 'file',
+    path: args.path
+  });
+
+  if (!result.success) {
+    console.error(`Error: ${result.error.message}`);
+    process.exit(1);
+  }
+
+  console.log(`Created store: ${storeName} (${result.data.id})`);
+  if ('path' in result.data) {
+    console.log(`Location: ${result.data.path}`);
+  }
+
+  // Auto-index
+  console.log('\nIndexing...');
+  const indexResult = await services.index.indexStore(result.data);
+
+  if (indexResult.success) {
+    console.log(`Indexed ${String(indexResult.data.documentsIndexed)} files`);
+  } else {
+    console.error(`Indexing failed: ${indexResult.error.message}`);
+  }
+}
+
+export async function handleIndex(args: {
+  store: string;
+}): Promise<void> {
+  // PWD is set by Claude Code to user's project directory
+  const services = await createServices(undefined, undefined, process.env['PWD']);
+  const store = await services.store.getByIdOrName(args.store);
+
+  if (store === undefined) {
+    console.error(`Store not found: ${args.store}`);
+    process.exit(1);
+  }
+
+  console.log(`Indexing ${store.name}...`);
+  const result = await services.index.indexStore(store);
+
+  if (result.success) {
+    console.log(`Indexed ${String(result.data.documentsIndexed)} documents in ${String(result.data.timeMs)}ms`);
+  } else {
+    console.error(`Error: ${result.error.message}`);
+    process.exit(1);
+  }
+}
+
+export async function handleStores(): Promise<void> {
+  // PWD is set by Claude Code to user's project directory
+  const services = await createServices(undefined, undefined, process.env['PWD']);
+  const stores = await services.store.list();
+
+  if (stores.length === 0) {
+    console.log('No stores found.');
+    console.log('\nCreate a store with:');
+    console.log('  /bluera-knowledge:add-repo <url> --name=<name>');
+    console.log('  /bluera-knowledge:add-folder <path> --name=<name>');
+    return;
+  }
+
+  // Table header
+  console.log('| Name | Type | ID | Source |');
+  console.log('|------|------|----|--------------------|');
+
+  // Table rows
+  for (const store of stores) {
+    const name = store.name;
+    const type = store.type;
+    const id = store.id;
+    let source = '';
+
+    if ('url' in store && store.url !== undefined) {
+      source = store.url;
+    } else if ('path' in store) {
+      source = store.path;
+    }
+
+    console.log(`| ${name} | ${type} | ${id.substring(0, 8)}... | ${source} |`);
+  }
+}
+
+export async function handleSuggest(): Promise<void> {
+  // PWD is set by Claude Code to user's project directory
+  const projectRoot = process.env['PWD'] ?? process.cwd();
+
+  console.log('Analyzing project dependencies...\n');
+
+  // Create analyzer instance
+  const services = await createServices(undefined, undefined, projectRoot);
+  const analyzer = new DependencyUsageAnalyzer();
+  const resolver = new RepoUrlResolver();
+
+  // Analyze with progress indicator
+  const spinner = ora('Scanning source files...').start();
+
+  const result = await analyzer.analyze(projectRoot, (current, total, message) => {
+    spinner.text = `${message} (${String(current)}/${String(total)})`;
+  });
+
+  spinner.stop();
+
+  if (!result.success) {
+    console.error(`Error: ${result.error.message}`);
+    process.exit(1);
+  }
+
+  const { usages, totalFilesScanned, skippedFiles } = result.data;
+
+  console.log(`✔ Scanned ${String(totalFilesScanned)} files${skippedFiles > 0 ? ` (skipped ${String(skippedFiles)})` : ''}\n`);
+
+  if (usages.length === 0) {
+    console.log('No external dependencies found in this project.');
+    console.log('\nMake sure you have a package.json or requirements.txt file.');
+    return;
+  }
+
+  // Filter out packages already in stores
+  const existingStores = await services.store.list();
+  const existingRepoNames = new Set(existingStores.map(s => s.name));
+
+  const newUsages = usages.filter(u => !existingRepoNames.has(u.packageName));
+
+  if (newUsages.length === 0) {
+    console.log('✔ All dependencies are already in knowledge stores!');
+    return;
+  }
+
+  // Show top 5 suggestions
+  const topSuggestions = newUsages.slice(0, 5);
+
+  console.log('Top dependencies by usage in this project:\n');
+  topSuggestions.forEach((usage, i) => {
+    console.log(`${String(i + 1)}. ${usage.packageName}`);
+    console.log(`   ${String(usage.importCount)} imports across ${String(usage.fileCount)} files\n`);
+  });
+
+  console.log('Searching for repository URLs...\n');
+
+  // For each package, find repo URL
+  for (const usage of topSuggestions) {
+    const repoResult = await resolver.findRepoUrl(
+      usage.packageName,
+      usage.language
+    );
+
+    if (repoResult.url !== null) {
+      console.log(`✔ ${usage.packageName}: ${repoResult.url}`);
+      console.log(`  /bluera-knowledge:add-repo ${repoResult.url} --name=${usage.packageName}\n`);
+    } else {
+      console.log(`✗ ${usage.packageName}: Could not find repository URL`);
+      console.log(`  You can manually add it: /bluera-knowledge:add-repo <url> --name=${usage.packageName}\n`);
+    }
+  }
+
+  console.log('Use the commands above to add repositories to your knowledge stores.');
+}

package/src/plugin/dependency-analyzer.test.ts

@@ -0,0 +1,380 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { analyzeDependencies } from './dependency-analyzer.js';
+import { mkdir, writeFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+describe('DependencyAnalyzer - Node.js Projects', () => {
+  let tempDir: string;
+
+  beforeAll(async () => {
+    tempDir = join(tmpdir(), `dep-analyzer-test-${Date.now()}`);
+    await mkdir(tempDir, { recursive: true });
+  });
+
+  afterAll(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('analyzes package.json dependencies', async () => {
+    const packageJson = {
+      name: 'test-project',
+      dependencies: {
+        react: '^18.0.0',
+        vue: '^3.0.0'
+      }
+    };
+
+    await writeFile(join(tempDir, 'package.json'), JSON.stringify(packageJson));
+
+    const suggestions = await analyzeDependencies(tempDir);
+
+    expect(suggestions.some(s => s.name === 'react')).toBe(true);
+    expect(suggestions.some(s => s.name === 'vue')).toBe(true);
+  });
+
+  it('includes devDependencies', async () => {
+    const packageJson = {
+      name: 'test-project',
+      dependencies: {
+        hono: '^3.0.0'
+      },
+      devDependencies: {
+        pino: '^8.0.0'
+      }
+    };
+
+    await writeFile(join(tempDir, 'package.json'), JSON.stringify(packageJson));
+
+    const suggestions = await analyzeDependencies(tempDir);
+
+    expect(suggestions.some(s => s.name === 'hono')).toBe(true);
+    expect(suggestions.some(s => s.name === 'pino')).toBe(true);
+  });
+
+  it('returns only known repositories', async () => {
+    const packageJson = {
+      name: 'test-project',
+      dependencies: {
+        react: '^18.0.0',
+        'some-unknown-package': '^1.0.0'
+      }
+    };
+
+    await writeFile(join(tempDir, 'package.json'), JSON.stringify(packageJson));
+
+    const suggestions = await analyzeDependencies(tempDir);
+
+    expect(suggestions.some(s => s.name === 'react')).toBe(true);
+    expect(suggestions.some(s => s.name === 'some-unknown-package')).toBe(false);
+  });
+
+  it('includes repository URL for known packages', async () => {
+    const packageJson = {
+      name: 'test-project',
+      dependencies: {
+        react: '^18.0.0'
+      }
+    };
+
+    await writeFile(join(tempDir, 'package.json'), JSON.stringify(packageJson));
+
+    const suggestions = await analyzeDependencies(tempDir);
+
+    const reactSuggestion = suggestions.find(s => s.name === 'react');
+    expect(reactSuggestion).toBeDefined();
+    expect(reactSuggestion?.url).toContain('github.com');
+  });
+
+  it('categorizes packages by importance', async () => {
+    const packageJson = {
+      name: 'test-project',
+      dependencies: {
+        react: '^18.0.0',
+        pino: '^8.0.0'
+      }
+    };
+
+    await writeFile(join(tempDir, 'package.json'), JSON.stringify(packageJson));
+
+    const suggestions = await analyzeDependencies(tempDir);
+
+    const reactSuggestion = suggestions.find(s => s.name === 'react');
+    const pinoSuggestion = suggestions.find(s => s.name === 'pino');
+
+    expect(reactSuggestion?.importance).toBe('critical');
+    expect(pinoSuggestion?.importance).toBe('medium');
+  });
+
+  it('includes reason for each suggestion', async () => {
+    const packageJson = {
+      name: 'test-project',
+      dependencies: {
+        react: '^18.0.0'
+      }
+    };
+
+    await writeFile(join(tempDir, 'package.json'), JSON.stringify(packageJson));
+
+    const suggestions = await analyzeDependencies(tempDir);
+
+    const reactSuggestion = suggestions.find(s => s.name === 'react');
+    expect(reactSuggestion?.reason).toBeTruthy();
+    expect(reactSuggestion?.reason).toContain('framework');
+  });
+
+  it('handles malformed package.json', async () => {
+    // Create a new temp dir for this test to avoid conflicts
+    const testDir = join(tempDir, `test-malformed-${Date.now()}`);
+    await mkdir(testDir, { recursive: true });
+
+    await writeFile(join(testDir, 'package.json'), '{ invalid json }');
+
+    // The function catches JSON parse errors and continues
+    // In this case it will just return empty array
+    try {
+      const suggestions = await analyzeDependencies(testDir);
+      expect(suggestions).toEqual([]);
+    } catch (error) {
+      // If it throws, that's also acceptable behavior
+      expect(error).toBeDefined();
+    }
+  });
+
+  it('handles missing package.json', async () => {
+    const emptyDir = join(tempDir, 'empty-dir');
+    await mkdir(emptyDir, { recursive: true });
+
+    const suggestions = await analyzeDependencies(emptyDir);
+
+    expect(suggestions).toEqual([]);
+  });
+});
+
+describe('DependencyAnalyzer - Python Projects', () => {
+  let tempDir: string;
+
+  beforeAll(async () => {
+    tempDir = join(tmpdir(), `dep-analyzer-python-test-${Date.now()}`);
+    await mkdir(tempDir, { recursive: true });
+  });
+
+  afterAll(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('analyzes requirements.txt', async () => {
+    const requirements = `fastapi==0.95.0
+pydantic>=1.10.0
+django==4.2.0`;
+
+    await writeFile(join(tempDir, 'requirements.txt'), requirements);
+
+    const suggestions = await analyzeDependencies(tempDir);
+
+    expect(suggestions.some(s => s.name === 'fastapi')).toBe(true);
+    expect(suggestions.some(s => s.name === 'pydantic')).toBe(true);
+    expect(suggestions.some(s => s.name === 'django')).toBe(true);
+  });
+
+  it('parses different version specifiers', async () => {
+    const requirements = `fastapi==0.95.0
+pydantic>=1.10.0
+flask~=2.0.0
+django>3.0`;
+
+    await writeFile(join(tempDir, 'requirements.txt'), requirements);
+
+    const suggestions = await analyzeDependencies(tempDir);
+
+    expect(suggestions.some(s => s.name === 'fastapi')).toBe(true);
+    expect(suggestions.some(s => s.name === 'pydantic')).toBe(true);
+    expect(suggestions.some(s => s.name === 'flask')).toBe(true);
+    expect(suggestions.some(s => s.name === 'django')).toBe(true);
+  });
+
+  it('ignores comments and blank lines', async () => {
+    const requirements = `# This is a comment
+fastapi==0.95.0
+
+# Another comment
+pydantic>=1.10.0
+`;
+
+    await writeFile(join(tempDir, 'requirements.txt'), requirements);
+
+    const suggestions = await analyzeDependencies(tempDir);
+
+    expect(suggestions.some(s => s.name === 'fastapi')).toBe(true);
+    expect(suggestions.some(s => s.name === 'pydantic')).toBe(true);
+  });
+
+  it('analyzes pyproject.toml', async () => {
+    const pyproject = `[project]
+name = "test-project"
+dependencies = [
+    "fastapi",
+    "pydantic",
+]`;
+
+    await writeFile(join(tempDir, 'pyproject.toml'), pyproject);
+
+    const suggestions = await analyzeDependencies(tempDir);
+
+    expect(suggestions.some(s => s.name === 'fastapi')).toBe(true);
+    expect(suggestions.some(s => s.name === 'pydantic')).toBe(true);
+  });
+});
+
+describe('DependencyAnalyzer - Mixed Projects', () => {
+  let tempDir: string;
+
+  beforeAll(async () => {
+    tempDir = join(tmpdir(), `dep-analyzer-mixed-test-${Date.now()}`);
+    await mkdir(tempDir, { recursive: true });
+  });
+
+  afterAll(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('combines Node.js and Python dependencies', async () => {
+    const packageJson = {
+      name: 'test-project',
+      dependencies: {
+        react: '^18.0.0'
+      }
+    };
+
+    const requirements = 'fastapi==0.95.0';
+
+    await writeFile(join(tempDir, 'package.json'), JSON.stringify(packageJson));
+    await writeFile(join(tempDir, 'requirements.txt'), requirements);
+
+    const suggestions = await analyzeDependencies(tempDir);
+
+    expect(suggestions.some(s => s.name === 'react')).toBe(true);
+    expect(suggestions.some(s => s.name === 'fastapi')).toBe(true);
+  });
+
+  it('removes duplicates across sources', async () => {
+    const packageJson = {
+      name: 'test-project',
+      dependencies: {
+        react: '^18.0.0'
+      },
+      devDependencies: {
+        react: '^18.0.0' // Duplicate
+      }
+    };
+
+    await writeFile(join(tempDir, 'package.json'), JSON.stringify(packageJson));
+
+    const suggestions = await analyzeDependencies(tempDir);
+
+    const reactSuggestions = suggestions.filter(s => s.name === 'react');
+    expect(reactSuggestions).toHaveLength(1);
+  });
+
+  it('sorts suggestions by importance', async () => {
+    const packageJson = {
+      name: 'test-project',
+      dependencies: {
+        pino: '^8.0.0',        // medium
+        react: '^18.0.0',      // critical
+        zod: '^3.0.0',         // high
+        express: '^4.0.0'      // high
+      }
+    };
+
+    await writeFile(join(tempDir, 'package.json'), JSON.stringify(packageJson));
+
+    const suggestions = await analyzeDependencies(tempDir);
+
+    // Critical should come first
+    expect(suggestions[0]?.importance).toBe('critical');
+
+    // Check ordering: critical > high > medium
+    for (let i = 0; i < suggestions.length - 1; i++) {
+      const current = suggestions[i];
+      const next = suggestions[i + 1];
+
+      if (current && next) {
+        const importanceOrder = { critical: 0, high: 1, medium: 2 };
+        const currentOrder = importanceOrder[current.importance];
+        const nextOrder = importanceOrder[next.importance];
+        expect(currentOrder).toBeLessThanOrEqual(nextOrder);
+      }
+    }
+  });
+});
+
+describe('DependencyAnalyzer - Edge Cases', () => {
+  let tempDir: string;
+
+  beforeAll(async () => {
+    tempDir = join(tmpdir(), `dep-analyzer-edge-test-${Date.now()}`);
+    await mkdir(tempDir, { recursive: true });
+  });
+
+  afterAll(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('handles empty dependencies object', async () => {
+    const packageJson = {
+      name: 'test-project',
+      dependencies: {}
+    };
+
+    await writeFile(join(tempDir, 'package.json'), JSON.stringify(packageJson));
+
+    const suggestions = await analyzeDependencies(tempDir);
+
+    expect(suggestions).toEqual([]);
+  });
+
+  it('handles package.json without dependencies field', async () => {
+    const packageJson = {
+      name: 'test-project',
+      version: '1.0.0'
+    };
+
+    await writeFile(join(tempDir, 'package.json'), JSON.stringify(packageJson));
+
+    const suggestions = await analyzeDependencies(tempDir);
+
+    expect(suggestions).toEqual([]);
+  });
+
+  it('handles empty requirements.txt', async () => {
+    await writeFile(join(tempDir, 'requirements.txt'), '');
+
+    const suggestions = await analyzeDependencies(tempDir);
+
+    expect(suggestions).toEqual([]);
+  });
+
+  it('uses current directory as default', async () => {
+    const packageJson = {
+      name: 'test-project',
+      dependencies: {
+        react: '^18.0.0'
+      }
+    };
+
+    await writeFile(join(tempDir, 'package.json'), JSON.stringify(packageJson));
+
+    // Mock process.cwd to return tempDir
+    const originalCwd = process.cwd();
+    const cwd = vi.spyOn(process, 'cwd');
+    cwd.mockReturnValue(tempDir);
+
+    try {
+      const suggestions = await analyzeDependencies();
+      expect(suggestions.some(s => s.name === 'react')).toBe(true);
+    } finally {
+      cwd.mockRestore();
+    }
+  });
+});