bluera-knowledge 0.14.0 → 0.14.1

package/src/plugin/dependency-analyzer.ts

@@ -1,210 +0,0 @@
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-
-export interface DependencySuggestion {
-  name: string;
-  url: string;
-  reason: string;
-  importance: 'critical' | 'high' | 'medium';
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-// Map of important libraries to their repos
-const KNOWN_REPOS: Record<
-  string,
-  { url: string; importance: 'critical' | 'high' | 'medium'; reason: string }
-> = {
-  vue: {
-    url: 'https://github.com/vuejs/core',
-    importance: 'critical',
-    reason: 'Core framework - essential for Vue.js development',
-  },
-  react: {
-    url: 'https://github.com/facebook/react',
-    importance: 'critical',
-    reason: 'Core framework - essential for React development',
-  },
-  pydantic: {
-    url: 'https://github.com/pydantic/pydantic',
-    importance: 'critical',
-    reason: 'Core validation library - heavily used',
-  },
-  fastapi: {
-    url: 'https://github.com/tiangolo/fastapi',
-    importance: 'critical',
-    reason: 'Core web framework - central to this project',
-  },
-  hono: {
-    url: 'https://github.com/honojs/hono',
-    importance: 'critical',
-    reason: 'Core web framework - central to this project',
-  },
-  express: {
-    url: 'https://github.com/expressjs/express',
-    importance: 'high',
-    reason: 'Web framework - frequently referenced',
-  },
-  pinia: {
-    url: 'https://github.com/vuejs/pinia',
-    importance: 'high',
-    reason: 'State management - frequently used',
-  },
-  pino: {
-    url: 'https://github.com/pinojs/pino',
-    importance: 'medium',
-    reason: 'Logging library - commonly used',
-  },
-  zod: {
-    url: 'https://github.com/colinhacks/zod',
-    importance: 'high',
-    reason: 'Schema validation - frequently used',
-  },
-  next: {
-    url: 'https://github.com/vercel/next.js',
-    importance: 'critical',
-    reason: 'Core framework - essential for Next.js development',
-  },
-  nuxt: {
-    url: 'https://github.com/nuxt/nuxt',
-    importance: 'critical',
-    reason: 'Core framework - essential for Nuxt development',
-  },
-  svelte: {
-    url: 'https://github.com/sveltejs/svelte',
-    importance: 'critical',
-    reason: 'Core framework - essential for Svelte development',
-  },
-  django: {
-    url: 'https://github.com/django/django',
-    importance: 'critical',
-    reason: 'Core framework - essential for Django development',
-  },
-  flask: {
-    url: 'https://github.com/pallets/flask',
-    importance: 'critical',
-    reason: 'Core framework - essential for Flask development',
-  },
-  prisma: {
-    url: 'https://github.com/prisma/prisma',
-    importance: 'high',
-    reason: 'ORM - database interactions',
-  },
-};
-
-export async function analyzeDependencies(
-  projectRoot: string = process.cwd()
-): Promise<DependencySuggestion[]> {
-  const suggestions: DependencySuggestion[] = [];
-
-  // Check Node.js projects
-  const packageJsonPath = join(projectRoot, 'package.json');
-  if (existsSync(packageJsonPath)) {
-    const content = await readFile(packageJsonPath, 'utf-8');
-    const parsed: unknown = JSON.parse(content);
-    if (isRecord(parsed)) {
-      suggestions.push(...analyzeNodeDependencies(parsed));
-    }
-  }
-
-  // Check Python projects
-  const reqPath = join(projectRoot, 'requirements.txt');
-  if (existsSync(reqPath)) {
-    const content = await readFile(reqPath, 'utf-8');
-    suggestions.push(...analyzePythonDependencies(content));
-  }
-
-  // Check pyproject.toml
-  const pyprojectPath = join(projectRoot, 'pyproject.toml');
-  if (existsSync(pyprojectPath)) {
-    const content = await readFile(pyprojectPath, 'utf-8');
-    suggestions.push(...analyzePyProjectDependencies(content));
-  }
-
-  // Remove duplicates and sort by importance
-  const unique = Array.from(new Map(suggestions.map((s) => [s.name, s])).values());
-  return unique.sort((a, b) => {
-    const order = { critical: 0, high: 1, medium: 2 };
-    return order[a.importance] - order[b.importance];
-  });
-}
-
-function analyzeNodeDependencies(pkg: Record<string, unknown>): DependencySuggestion[] {
-  const suggestions: DependencySuggestion[] = [];
-
-  const deps = pkg['dependencies'];
-  const devDeps = pkg['devDependencies'];
-
-  const allDeps = {
-    ...(isRecord(deps) ? deps : {}),
-    ...(isRecord(devDeps) ? devDeps : {}),
-  };
-
-  for (const name of Object.keys(allDeps)) {
-    const known = KNOWN_REPOS[name];
-    if (known !== undefined) {
-      suggestions.push({
-        name,
-        url: known.url,
-        importance: known.importance,
-        reason: known.reason,
-      });
-    }
-  }
-
-  return suggestions;
-}
-
-function analyzePythonDependencies(content: string): DependencySuggestion[] {
-  const suggestions: DependencySuggestion[] = [];
-  const lines = content.split('\n');
-
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed === '' || trimmed.startsWith('#')) continue;
-
-    // Parse package name (before ==, >=, etc.)
-    const match = /^([a-zA-Z0-9_-]+)/.exec(trimmed);
-    if (match?.[1] !== undefined) {
-      const name = match[1].toLowerCase();
-      const known = KNOWN_REPOS[name];
-      if (known !== undefined) {
-        suggestions.push({
-          name,
-          url: known.url,
-          importance: known.importance,
-          reason: known.reason,
-        });
-      }
-    }
-  }
-
-  return suggestions;
-}
-
-function analyzePyProjectDependencies(content: string): DependencySuggestion[] {
-  const suggestions: DependencySuggestion[] = [];
-
-  // Simple parsing - look for dependencies in [project.dependencies] or [tool.poetry.dependencies]
-  const depMatches = content.matchAll(/"([a-zA-Z0-9_-]+)"/g);
-
-  for (const match of depMatches) {
-    if (match[1] !== undefined) {
-      const name = match[1].toLowerCase();
-      const known = KNOWN_REPOS[name];
-      if (known !== undefined) {
-        suggestions.push({
-          name,
-          url: known.url,
-          importance: known.importance,
-          reason: known.reason,
-        });
-      }
-    }
-  }
-
-  return suggestions;
-}

package/src/plugin/git-clone.test.ts

@@ -1,387 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { cloneRepository, isGitUrl, extractRepoName } from './git-clone.js';
-import type { ChildProcess } from 'node:child_process';
-import { EventEmitter } from 'node:events';
-import { rm, mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-// Mock child_process
-vi.mock('node:child_process', () => ({
-  spawn: vi.fn(),
-}));
-
-describe('GitClone - cloneRepository', () => {
-  let tempDir: string;
-  let mockSpawn: ReturnType<typeof vi.fn>;
-
-  beforeEach(async () => {
-    tempDir = join(tmpdir(), `git-clone-test-${Date.now()}`);
-    await mkdir(tempDir, { recursive: true });
-
-    const { spawn } = await import('node:child_process');
-    mockSpawn = vi.mocked(spawn);
-  });
-
-  afterEach(async () => {
-    await rm(tempDir, { recursive: true, force: true });
-    vi.clearAllMocks();
-  });
-
-  it('clones repository successfully', async () => {
-    const mockProcess = new EventEmitter() as ChildProcess;
-    mockProcess.stderr = new EventEmitter() as any;
-
-    mockSpawn.mockImplementation(() => {
-      // Emit close event immediately after spawn
-      setImmediate(() => {
-        mockProcess.emit('close', 0);
-      });
-      return mockProcess;
-    });
-
-    const result = await cloneRepository({
-      url: 'https://github.com/user/repo.git',
-      targetDir: join(tempDir, 'repo'),
-    });
-
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data).toBe(join(tempDir, 'repo'));
-    }
-  });
-
-  it('passes correct arguments to git clone', async () => {
-    const mockProcess = new EventEmitter() as ChildProcess;
-    mockProcess.stderr = new EventEmitter() as any;
-
-    mockSpawn.mockImplementation(() => {
-      setImmediate(() => mockProcess.emit('close', 0));
-      return mockProcess;
-    });
-
-    await cloneRepository({
-      url: 'https://github.com/user/repo.git',
-      targetDir: join(tempDir, 'repo'),
-    });
-
-    expect(mockSpawn).toHaveBeenCalledWith(
-      'git',
-      ['clone', '--depth', '1', 'https://github.com/user/repo.git', join(tempDir, 'repo')],
-      expect.any(Object)
-    );
-  });
-
-  it('includes branch when specified', async () => {
-    const mockProcess = new EventEmitter() as ChildProcess;
-    mockProcess.stderr = new EventEmitter() as any;
-
-    mockSpawn.mockImplementation(() => {
-      setImmediate(() => mockProcess.emit('close', 0));
-      return mockProcess;
-    });
-
-    await cloneRepository({
-      url: 'https://github.com/user/repo.git',
-      targetDir: join(tempDir, 'repo'),
-      branch: 'develop',
-    });
-
-    expect(mockSpawn).toHaveBeenCalledWith(
-      'git',
-      [
-        'clone',
-        '--depth',
-        '1',
-        '--branch',
-        'develop',
-        'https://github.com/user/repo.git',
-        join(tempDir, 'repo'),
-      ],
-      expect.any(Object)
-    );
-  });
-
-  it('uses custom depth when provided', async () => {
-    const mockProcess = new EventEmitter() as ChildProcess;
-    mockProcess.stderr = new EventEmitter() as any;
-
-    mockSpawn.mockImplementation(() => {
-      setImmediate(() => mockProcess.emit('close', 0));
-      return mockProcess;
-    });
-
-    await cloneRepository({
-      url: 'https://github.com/user/repo.git',
-      targetDir: join(tempDir, 'repo'),
-      depth: 10,
-    });
-
-    expect(mockSpawn).toHaveBeenCalledWith(
-      'git',
-      ['clone', '--depth', '10', 'https://github.com/user/repo.git', join(tempDir, 'repo')],
-      expect.any(Object)
-    );
-  });
-
-  it('defaults to depth 1 for shallow clone', async () => {
-    const mockProcess = new EventEmitter() as ChildProcess;
-    mockProcess.stderr = new EventEmitter() as any;
-
-    mockSpawn.mockImplementation(() => {
-      setImmediate(() => mockProcess.emit('close', 0));
-      return mockProcess;
-    });
-
-    await cloneRepository({
-      url: 'https://github.com/user/repo.git',
-      targetDir: join(tempDir, 'repo'),
-    });
-
-    expect(mockSpawn).toHaveBeenCalledWith(
-      'git',
-      expect.arrayContaining(['--depth', '1']),
-      expect.any(Object)
-    );
-  });
-
-  it('returns error on non-zero exit code', async () => {
-    const mockProcess = new EventEmitter() as ChildProcess;
-    mockProcess.stderr = new EventEmitter() as any;
-
-    mockSpawn.mockImplementation(() => {
-      setImmediate(() => {
-        (mockProcess.stderr as any).emit('data', Buffer.from('Repository not found'));
-        mockProcess.emit('close', 128);
-      });
-      return mockProcess;
-    });
-
-    const result = await cloneRepository({
-      url: 'https://github.com/user/nonexistent.git',
-      targetDir: join(tempDir, 'repo'),
-    });
-
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error.message).toContain('Git clone failed');
-      expect(result.error.message).toContain('Repository not found');
-    }
-  });
-
-  it('captures stderr output on failure', async () => {
-    const mockProcess = new EventEmitter() as ChildProcess;
-    mockProcess.stderr = new EventEmitter() as any;
-
-    mockSpawn.mockImplementation(() => {
-      setImmediate(() => {
-        (mockProcess.stderr as any).emit('data', Buffer.from('Error: Authentication failed\n'));
-        (mockProcess.stderr as any).emit('data', Buffer.from('fatal: unable to access\n'));
-        mockProcess.emit('close', 1);
-      });
-      return mockProcess;
-    });
-
-    const result = await cloneRepository({
-      url: 'https://github.com/user/repo.git',
-      targetDir: join(tempDir, 'repo'),
-    });
-
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error.message).toContain('Authentication failed');
-      expect(result.error.message).toContain('fatal: unable to access');
-    }
-  });
-
-  it('handles network errors', async () => {
-    const mockProcess = new EventEmitter() as ChildProcess;
-    mockProcess.stderr = new EventEmitter() as any;
-
-    mockSpawn.mockImplementation(() => {
-      setImmediate(() => {
-        (mockProcess.stderr as any).emit('data', Buffer.from('fatal: unable to connect'));
-        mockProcess.emit('close', 128);
-      });
-      return mockProcess;
-    });
-
-    const result = await cloneRepository({
-      url: 'https://github.com/user/repo.git',
-      targetDir: join(tempDir, 'repo'),
-    });
-
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error.message).toContain('unable to connect');
-    }
-  });
-
-  it('handles permission errors', async () => {
-    const mockProcess = new EventEmitter() as ChildProcess;
-    mockProcess.stderr = new EventEmitter() as any;
-
-    mockSpawn.mockImplementation(() => {
-      setImmediate(() => {
-        (mockProcess.stderr as any).emit('data', Buffer.from('Permission denied'));
-        mockProcess.emit('close', 128);
-      });
-      return mockProcess;
-    });
-
-    const result = await cloneRepository({
-      url: 'https://github.com/user/repo.git',
-      targetDir: join(tempDir, 'repo'),
-    });
-
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error.message).toContain('Permission denied');
-    }
-  });
-
-  it('handles branch not found error', async () => {
-    const mockProcess = new EventEmitter() as ChildProcess;
-    mockProcess.stderr = new EventEmitter() as any;
-
-    mockSpawn.mockImplementation(() => {
-      setImmediate(() => {
-        (mockProcess.stderr as any).emit(
-          'data',
-          Buffer.from('Remote branch nonexistent-branch not found')
-        );
-        mockProcess.emit('close', 128);
-      });
-      return mockProcess;
-    });
-
-    const result = await cloneRepository({
-      url: 'https://github.com/user/repo.git',
-      targetDir: join(tempDir, 'repo'),
-      branch: 'nonexistent-branch',
-    });
-
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error.message).toContain('not found');
-    }
-  });
-
-  it('handles spawn error when git is not installed', async () => {
-    const mockProcess = new EventEmitter() as ChildProcess;
-    mockProcess.stderr = new EventEmitter() as any;
-
-    mockSpawn.mockImplementation(() => {
-      setImmediate(() => {
-        mockProcess.emit('error', new Error('spawn git ENOENT'));
-      });
-      return mockProcess;
-    });
-
-    const result = await cloneRepository({
-      url: 'https://github.com/user/repo.git',
-      targetDir: join(tempDir, 'repo'),
-    });
-
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error.message).toContain('spawn git ENOENT');
-    }
-  });
-
-  it('handles spawn error with permission denied', async () => {
-    const mockProcess = new EventEmitter() as ChildProcess;
-    mockProcess.stderr = new EventEmitter() as any;
-
-    mockSpawn.mockImplementation(() => {
-      setImmediate(() => {
-        mockProcess.emit('error', new Error('spawn git EACCES'));
-      });
-      return mockProcess;
-    });
-
-    const result = await cloneRepository({
-      url: 'https://github.com/user/repo.git',
-      targetDir: join(tempDir, 'repo'),
-    });
-
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error.message).toContain('EACCES');
-    }
-  });
-});
-
-describe('GitClone - isGitUrl', () => {
-  it('recognizes https URLs', () => {
-    expect(isGitUrl('https://github.com/user/repo.git')).toBe(true);
-  });
-
-  it('recognizes http URLs', () => {
-    expect(isGitUrl('http://github.com/user/repo.git')).toBe(true);
-  });
-
-  it('recognizes git@ SSH URLs', () => {
-    expect(isGitUrl('git@github.com:user/repo.git')).toBe(true);
-  });
-
-  it('rejects relative paths', () => {
-    expect(isGitUrl('./local/path')).toBe(false);
-  });
-
-  it('rejects absolute file paths', () => {
-    expect(isGitUrl('/absolute/path')).toBe(false);
-  });
-
-  it('rejects plain strings', () => {
-    expect(isGitUrl('just-text')).toBe(false);
-  });
-});
-
-describe('GitClone - extractRepoName', () => {
-  it('extracts name from HTTPS URL with .git', () => {
-    const name = extractRepoName('https://github.com/user/my-repo.git');
-    expect(name).toBe('my-repo');
-  });
-
-  it('extracts name from HTTPS URL without .git', () => {
-    const name = extractRepoName('https://github.com/user/my-repo');
-    expect(name).toBe('my-repo');
-  });
-
-  it('extracts name from SSH URL', () => {
-    const name = extractRepoName('git@github.com:user/my-repo.git');
-    expect(name).toBe('my-repo');
-  });
-
-  it('extracts name from nested path', () => {
-    const name = extractRepoName('https://gitlab.com/org/subgroup/project.git');
-    expect(name).toBe('project');
-  });
-
-  it('handles URL with trailing slash', () => {
-    const name = extractRepoName('https://github.com/user/repo.git/');
-    // Trailing slash makes the regex not match, so returns default 'repository'
-    expect(name).toBe('repository');
-  });
-
-  it('returns "repository" for invalid URL', () => {
-    const name = extractRepoName('https://github.com/');
-    expect(name).toBe('repository');
-  });
-
-  it('extracts name from GitHub shorthand', () => {
-    const name = extractRepoName('github.com/user/awesome-project');
-    expect(name).toBe('awesome-project');
-  });
-
-  it('handles dashes and underscores in repo name', () => {
-    const name = extractRepoName('https://github.com/user/my_cool-repo.git');
-    expect(name).toBe('my_cool-repo');
-  });
-
-  it('handles numeric repo names', () => {
-    const name = extractRepoName('https://github.com/user/123-repo.git');
-    expect(name).toBe('123-repo');
-  });
-});

package/src/plugin/git-clone.ts

@@ -1,57 +0,0 @@
-import { spawn } from 'node:child_process';
-import { mkdir } from 'node:fs/promises';
-import { ok, err } from '../types/result.js';
-import type { Result } from '../types/result.js';
-
-export interface CloneOptions {
-  url: string;
-  targetDir: string;
-  branch?: string;
-  depth?: number;
-}
-
-export async function cloneRepository(options: CloneOptions): Promise<Result<string>> {
-  const { url, targetDir, branch, depth = 1 } = options;
-
-  await mkdir(targetDir, { recursive: true });
-
-  const args = ['clone', '--depth', String(depth)];
-  if (branch !== undefined) {
-    args.push('--branch', branch);
-  }
-  args.push(url, targetDir);
-
-  return new Promise((resolve) => {
-    const git = spawn('git', args, { stdio: ['ignore', 'pipe', 'pipe'] });
-
-    let stderr = '';
-    git.stderr.on('data', (data: Buffer) => {
-      stderr += data.toString();
-    });
-
-    git.on('error', (error: Error) => {
-      resolve(err(error));
-    });
-
-    git.on('close', (code: number | null) => {
-      if (code === 0) {
-        resolve(ok(targetDir));
-      } else {
-        resolve(err(new Error(`Git clone failed: ${stderr}`)));
-      }
-    });
-  });
-}
-
-export function isGitUrl(source: string): boolean {
-  return source.startsWith('http://') || source.startsWith('https://') || source.startsWith('git@');
-}
-
-export function extractRepoName(url: string): string {
-  const match = /\/([^/]+?)(\.git)?$/.exec(url);
-  const name = match?.[1];
-  if (name === undefined) {
-    return 'repository';
-  }
-  return name;
-}