forge-server 0.1.0

package/src/cli.ts

@@ -0,0 +1,655 @@
+#!/usr/bin/env node
+// cli.ts — B20
+// Thin CLI for dk-forge-server operations.
+//
+// Commands:
+//   forge init --name <name> --stack <tags...> [--sharing team|private|public] [--org <org>] [--path <path>]
+//   forge register [--path <path>]
+//   forge status [--project <id>] [--all]
+//   forge knowledge list|search|migrate|sync [--query <text>] [--category gotcha|pattern|decision|convention]
+//   forge repos list|info|remove [--id <repo_id>]
+//
+// For init/register: operates directly on filesystem + SQLite, no server needed.
+// For status/knowledge/repos: reads SQLite directly (no server connection required).
+
+import { resolve, join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { PipelineDB } from './storage/sqlite.js';
+import { RepoRegistry } from './knowledge/registry.js';
+import { KnowledgeYamlStore } from './knowledge/store.js';
+import { QdrantVectorStore } from './storage/qdrant-store.js';
+import { FalkorDBGraphStore } from './storage/falkordb-store.js';
+import { LRUFileContentCache } from './storage/file-cache.js';
+import { fullIndex } from './ingestion/indexer.js';
+import type { RepoConfig } from './util/types.js';
+
+// ---------------------------------------------------------------------------
+// Argument parsing
+// ---------------------------------------------------------------------------
+
+interface ParsedArgs {
+  command: string;
+  subcommand: string;
+  flags: Record<string, string | string[] | boolean | true>;
+  positional: string[];
+}
+
+function parseArgs(argv: string[]): ParsedArgs {
+  // argv[0] = 'node', argv[1] = 'cli.js', argv[2] = command...
+  const args = argv.slice(2);
+  const command = args[0] ?? '';
+  const subcommand = args[1]?.startsWith('--') ? '' : (args[1] ?? '');
+  const startIdx = subcommand ? 2 : 1;
+
+  const flags: Record<string, string | string[] | boolean | true> = {};
+  const positional: string[] = [];
+
+  let i = startIdx;
+  while (i < args.length) {
+    const arg = args[i]!;
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      const next = args[i + 1];
+
+      if (!next || next.startsWith('--')) {
+        flags[key] = true;
+        i += 1;
+      } else if (key === 'stack') {
+        // --stack can have multiple values before the next flag
+        const values: string[] = [];
+        let j = i + 1;
+        while (j < args.length && !args[j]!.startsWith('--')) {
+          values.push(args[j]!);
+          j++;
+        }
+        flags[key] = values;
+        i = j;
+      } else {
+        flags[key] = next;
+        i += 2;
+      }
+    } else {
+      positional.push(arg);
+      i += 1;
+    }
+  }
+
+  return { command, subcommand, flags, positional };
+}
+
+function getFlag(flags: Record<string, unknown>, key: string): string | undefined {
+  const val = flags[key];
+  return typeof val === 'string' ? val : undefined;
+}
+
+function getFlagArray(flags: Record<string, unknown>, key: string): string[] {
+  const val = flags[key];
+  if (Array.isArray(val)) return val as string[];
+  if (typeof val === 'string') return [val];
+  return [];
+}
+
+function getFlagBool(flags: Record<string, unknown>, key: string): boolean {
+  return flags[key] === true;
+}
+
+// ---------------------------------------------------------------------------
+// Database helper — opens the shared pipeline.db
+// ---------------------------------------------------------------------------
+
+function openDB(): PipelineDB {
+  const dbPath = process.env['FORGE_DB_PATH'] ?? join(homedir(), '.forge', 'pipeline.db');
+  const db = new PipelineDB(dbPath);
+  db.initialize();
+  return db;
+}
+
+// ---------------------------------------------------------------------------
+// Output helpers
+// ---------------------------------------------------------------------------
+
+function print(obj: unknown): void {
+  console.log(JSON.stringify(obj, null, 2));
+}
+
+function printError(message: string, exitCode = 1): never {
+  console.error(`Error: ${message}`);
+  process.exit(exitCode);
+}
+
+function printHelp(): void {
+  console.log(`
+dk-forge-server CLI
+
+Usage:
+  forge init --name <name> --stack <tag...> [--sharing team|private|public] [--org <org>] [--path <dir>]
+  forge register [--path <dir>]
+  forge index [--path <dir>] [--repo-id <id>] [--force]
+  forge status [--project <id>] [--all]
+  forge knowledge list [--category gotcha|pattern|decision|convention] [--path <dir>]
+  forge knowledge search --query <text> [--category gotcha|pattern|decision|convention] [--path <dir>]
+  forge repos list
+  forge repos info --id <repo_id>
+  forge repos remove --id <repo_id>
+
+Options:
+  --name       Project name for forge init
+  --stack      Space-separated stack tags (nestjs drizzle react postgresql)
+  --sharing    Sharing mode: team | private | public (default: private)
+  --org        Organization identifier
+  --path       Target directory (default: current directory)
+  --repo-id    Repo ID (for index command)
+  --force      Force re-index even if files haven't changed
+  --project    Project ID for status command
+  --all        Show all projects (for status command)
+  --query      Search query (for knowledge search)
+  --category   Knowledge category filter
+  --id         Repo ID (for repos info/remove)
+
+Examples:
+  forge init --name my-app --stack nestjs drizzle --sharing team --org acme
+  forge register
+  forge index --path /path/to/repo
+  forge status --all
+  forge knowledge list --category gotcha
+  forge knowledge search --query "NestJS circular dependency"
+  forge repos list
+`.trim());
+}
+
+// ---------------------------------------------------------------------------
+// Commands
+// ---------------------------------------------------------------------------
+
+async function cmdInit(flags: Record<string, unknown>): Promise<void> {
+  const name = getFlag(flags, 'name');
+  if (!name) printError('--name is required for init');
+
+  const stack = getFlagArray(flags, 'stack');
+  if (stack.length === 0) printError('--stack requires at least one tag (e.g., --stack nestjs drizzle)');
+
+  const sharing = (getFlag(flags, 'sharing') ?? 'private') as 'team' | 'private' | 'public';
+  const org = getFlag(flags, 'org');
+  const targetPath = resolve(getFlag(flags, 'path') ?? process.cwd());
+
+  const db = openDB();
+  const registry = new RepoRegistry(db);
+
+  try {
+    const manifest = { name, stack, sharing, org, repo_id_override: null as string | null };
+    const { forgePath, filesCreated } = registry.initForge(targetPath, manifest);
+
+    print({
+      success: true,
+      forge_dir: forgePath,
+      manifest_path: join(forgePath, 'manifest.yaml'),
+      knowledge_dir: join(forgePath, 'knowledge'),
+      files_created: filesCreated,
+      message: `Initialized forge in ${forgePath}. Run 'forge register' to register this repo.`,
+    });
+  } catch (err) {
+    printError(String(err));
+  } finally {
+    db.close();
+  }
+}
+
+async function cmdRegister(flags: Record<string, unknown>): Promise<void> {
+  const targetPath = resolve(getFlag(flags, 'path') ?? process.cwd());
+  const forgePath = join(targetPath, '.forge');
+
+  if (!existsSync(join(forgePath, 'manifest.yaml'))) {
+    printError(
+      `No .forge/manifest.yaml found at ${forgePath}.\n` +
+      `Run 'forge init --name <name> --stack <tags...>' first.`,
+    );
+  }
+
+  const db = openDB();
+  const registry = new RepoRegistry(db);
+
+  try {
+    const result = await registry.register(targetPath);
+    print({
+      success: true,
+      ...result,
+      message: result.newly_registered
+        ? `Registered repo '${result.name}' (id: ${result.repo_id})`
+        : `Updated repo '${result.name}' (id: ${result.repo_id}) — last_seen_at refreshed`,
+    });
+  } catch (err) {
+    printError(String(err));
+  } finally {
+    db.close();
+  }
+}
+
+function cmdStatus(flags: Record<string, unknown>): void {
+  const db = openDB();
+
+  try {
+    const projectId = getFlag(flags, 'project');
+    const showAll = getFlagBool(flags, 'all');
+
+    if (projectId) {
+      // Show single project
+      const row = db.get<{
+        id: string;
+        name: string;
+        current_phase: string;
+        status: string;
+        tier: string;
+        created_at: number;
+        updated_at: number;
+      }>(`SELECT * FROM projects WHERE id = ?`, [projectId]);
+
+      if (!row) {
+        printError(`Project not found: ${projectId}`);
+      }
+
+      print({
+        project_id: row.id,
+        name: row.name,
+        current_phase: row.current_phase,
+        status: row.status,
+        tier: row.tier,
+        created_at: new Date(row.created_at).toISOString(),
+        updated_at: new Date(row.updated_at).toISOString(),
+      });
+    } else {
+      // Show all active projects (or all if --all)
+      const whereClause = showAll ? '' : `WHERE status = 'active'`;
+      const rows = db.all<{
+        id: string;
+        name: string;
+        current_phase: string;
+        status: string;
+        tier: string;
+        created_at: number;
+        updated_at: number;
+      }>(`SELECT id, name, current_phase, status, tier, created_at, updated_at FROM projects ${whereClause} ORDER BY updated_at DESC`);
+
+      if (rows.length === 0) {
+        print({ projects: [], message: showAll ? 'No projects found.' : 'No active projects. Use --all to see all projects.' });
+        return;
+      }
+
+      print({
+        projects: rows.map(r => ({
+          project_id: r.id,
+          name: r.name,
+          current_phase: r.current_phase,
+          status: r.status,
+          tier: r.tier,
+          updated_at: new Date(r.updated_at).toISOString(),
+        })),
+        count: rows.length,
+      });
+    }
+  } finally {
+    db.close();
+  }
+}
+
+function cmdKnowledge(subcommand: string, flags: Record<string, unknown>): void {
+  const targetPath = resolve(getFlag(flags, 'path') ?? process.cwd());
+  const forgePath = join(targetPath, '.forge');
+
+  if (!existsSync(forgePath)) {
+    printError(`No .forge/ directory found at ${targetPath}. Run 'forge init' first.`);
+  }
+
+  const yamlStore = new KnowledgeYamlStore(forgePath);
+  const category = getFlag(flags, 'category') as 'gotcha' | 'pattern' | 'decision' | 'convention' | undefined;
+
+  switch (subcommand) {
+    case 'list': {
+      const items = category ? yamlStore.readCategory(category) : yamlStore.readAll();
+      print({
+        category: category ?? 'all',
+        count: items.length,
+        items: items.map(i => ({
+          id: i.id,
+          title: i.title,
+          confidence: i.confidence,
+          stack_tags: i.stack_tags,
+          source: i.source,
+        })),
+      });
+      break;
+    }
+
+    case 'search': {
+      const query = getFlag(flags, 'query');
+      if (!query) printError('--query is required for knowledge search');
+
+      const queryLower = query.toLowerCase();
+      const items = category ? yamlStore.readCategory(category) : yamlStore.readAll();
+
+      // Simple text search over title + content
+      const matches = items.filter(i =>
+        i.title.toLowerCase().includes(queryLower) ||
+        i.content.toLowerCase().includes(queryLower),
+      );
+
+      print({
+        query,
+        category: category ?? 'all',
+        count: matches.length,
+        items: matches.map(i => ({
+          id: i.id,
+          title: i.title,
+          content: i.content.slice(0, 300),
+          confidence: i.confidence,
+          stack_tags: i.stack_tags,
+        })),
+        note: 'This is local YAML text search. For semantic search, use forge.search_knowledge via MCP.',
+      });
+      break;
+    }
+
+    case 'sync': {
+      // Re-sync all knowledge items by re-initializing missing files
+      yamlStore.initialize();
+      const all = yamlStore.readAll();
+      print({
+        success: true,
+        message: `Knowledge files verified/created in ${forgePath}/knowledge/`,
+        total_items: all.length,
+      });
+      break;
+    }
+
+    case 'migrate': {
+      // Placeholder: migration from CLAUDE.md is handled by a migration module
+      print({
+        success: false,
+        message: 'Knowledge migration from CLAUDE.md is not yet implemented in the CLI. Use forge.register to sync YAML to Qdrant.',
+      });
+      break;
+    }
+
+    default:
+      printError(`Unknown knowledge subcommand: '${subcommand}'. Available: list, search, sync, migrate`);
+  }
+}
+
+function cmdRepos(subcommand: string, flags: Record<string, unknown>): void {
+  const db = openDB();
+
+  try {
+    switch (subcommand) {
+      case 'list': {
+        const rows = db.all<{
+          id: string;
+          name: string;
+          path: string;
+          remote: string | null;
+          stack: string;
+          sharing: string;
+          last_seen_at: number;
+        }>(`SELECT id, name, path, remote, stack, sharing, last_seen_at FROM repos ORDER BY last_seen_at DESC`);
+
+        print({
+          count: rows.length,
+          repos: rows.map(r => {
+            let stack: string[] = [];
+            try { stack = JSON.parse(r.stack) as string[]; } catch {}
+            return {
+              id: r.id,
+              name: r.name,
+              path: r.path,
+              remote: r.remote,
+              stack,
+              sharing: r.sharing,
+              last_seen: new Date(r.last_seen_at).toISOString(),
+            };
+          }),
+        });
+        break;
+      }
+
+      case 'info': {
+        const id = getFlag(flags, 'id');
+        if (!id) printError('--id is required for repos info');
+
+        const row = db.get<{
+          id: string;
+          name: string;
+          path: string;
+          remote: string | null;
+          stack: string;
+          sharing: string;
+          org: string | null;
+          registered_at: number;
+          last_seen_at: number;
+          manifest_hash: string | null;
+        }>(`SELECT * FROM repos WHERE id = ?`, [id]);
+
+        if (!row) printError(`Repo not found: ${id}`);
+
+        let stack: string[] = [];
+        try { stack = JSON.parse(row.stack) as string[]; } catch {}
+
+        // Count projects for this repo
+        const projectCount = db.get<{ cnt: number }>(
+          `SELECT COUNT(*) as cnt FROM projects WHERE repo_id = ?`,
+          [id],
+        );
+
+        print({
+          id: row.id,
+          name: row.name,
+          path: row.path,
+          remote: row.remote,
+          stack,
+          sharing: row.sharing,
+          org: row.org,
+          registered_at: new Date(row.registered_at).toISOString(),
+          last_seen_at: new Date(row.last_seen_at).toISOString(),
+          manifest_hash: row.manifest_hash,
+          project_count: projectCount?.cnt ?? 0,
+        });
+        break;
+      }
+
+      case 'remove': {
+        const id = getFlag(flags, 'id');
+        if (!id) printError('--id is required for repos remove');
+
+        const existing = db.get<{ id: string }>(`SELECT id FROM repos WHERE id = ?`, [id]);
+        if (!existing) printError(`Repo not found: ${id}`);
+
+        db.run(`DELETE FROM repos WHERE id = ?`, [id]);
+
+        print({
+          success: true,
+          message: `Repo ${id} removed from registry. Note: Qdrant knowledge items are NOT removed. Restart the server to clear them.`,
+        });
+        break;
+      }
+
+      default:
+        printError(`Unknown repos subcommand: '${subcommand}'. Available: list, info, remove`);
+    }
+  } finally {
+    db.close();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Index command
+// ---------------------------------------------------------------------------
+
+async function cmdIndex(flags: Record<string, unknown>): Promise<void> {
+  const db = openDB();
+  const registry = new RepoRegistry(db);
+
+  try {
+    // Resolve repo: by --repo-id or by --path
+    const repoId = getFlag(flags, 'repo-id');
+    const targetPath = resolve(getFlag(flags, 'path') ?? process.cwd());
+    const force = getFlagBool(flags, 'force');
+
+    let repo;
+    if (repoId) {
+      repo = registry.getRepo(repoId);
+      if (!repo) printError(`Repo not found: ${repoId}. Run 'forge register' first.`);
+    } else {
+      repo = registry.findRepoByPath(targetPath);
+      if (!repo) {
+        printError(
+          `No registered repo found at ${targetPath}. Run 'forge register' first.`,
+        );
+      }
+    }
+
+    console.log(`Indexing repo '${repo.name}' (id: ${repo.id}) at ${repo.path}...`);
+
+    // Connect to Qdrant
+    const qdrantUrl = process.env['QDRANT_URL'] ?? 'http://localhost:6333';
+    const vectorStore = new QdrantVectorStore(qdrantUrl);
+    const qdrantHealthy = await vectorStore.isHealthy();
+    if (!qdrantHealthy) {
+      printError(`Qdrant not reachable at ${qdrantUrl}. Start Qdrant first.`);
+    }
+    await vectorStore.ensureCollections(384);
+
+    // Connect to FalkorDB (graceful degradation)
+    const falkorHost = process.env['FALKORDB_HOST'] ?? 'localhost';
+    const falkorPort = parseInt(process.env['FALKORDB_PORT'] ?? '6380', 10);
+    let graphStore: FalkorDBGraphStore | null = null;
+    try {
+      const falkor = new FalkorDBGraphStore(`redis://${falkorHost}:${falkorPort}`);
+      await falkor.connect();
+      const falkorHealthy = await falkor.isHealthy();
+      if (falkorHealthy) {
+        graphStore = falkor;
+        console.log('FalkorDB connected');
+      } else {
+        console.log('FalkorDB unavailable — indexing without graph store');
+        try { await falkor.disconnect(); } catch {}
+      }
+    } catch {
+      console.log('FalkorDB unavailable — indexing without graph store');
+    }
+
+    // Create a no-op graph store if FalkorDB is unavailable
+    const effectiveGraphStore = graphStore ?? createNoOpGraphStore();
+
+    // File cache
+    const fileCache = new LRUFileContentCache();
+
+    // Build RepoConfig
+    const repoConfig: RepoConfig = {
+      id: repo.id,
+      path: repo.path,
+      ownership: 'owned',
+      watch: false,
+      languages: repo.stack,
+    };
+
+    // Run full index
+    const result = await fullIndex({
+      repoConfig,
+      graphStore: effectiveGraphStore,
+      vectorStore,
+      fileCache,
+      allRepos: [repoConfig],
+    });
+
+    print({
+      success: true,
+      repo_id: result.repoId,
+      files_processed: result.filesProcessed,
+      files_skipped: result.filesSkipped,
+      files_errored: result.filesErrored,
+      chunks_created: result.chunksCreated,
+      knowledge_items_extracted: result.knowledgeItemsExtracted,
+      duration_ms: result.durationMs,
+      errors: result.errors.length > 0 ? result.errors.slice(0, 10) : undefined,
+    });
+
+    // Cleanup
+    if (graphStore) {
+      try { await graphStore.disconnect(); } catch {}
+    }
+  } finally {
+    db.close();
+  }
+}
+
+/**
+ * Minimal no-op graph store for when FalkorDB is unavailable.
+ * Allows indexing to proceed with vector-only storage.
+ */
+function createNoOpGraphStore(): FalkorDBGraphStore {
+  return {
+    connect: async () => {},
+    disconnect: async () => {},
+    isHealthy: async () => false,
+    query: async () => ({ nodes: [], edges: [], raw: [] }),
+    upsertNode: async () => {},
+    upsertEdge: async () => {},
+    deleteFile: async () => {},
+    deleteRepo: async () => {},
+    getCounts: async () => ({ totalNodes: 0, totalEdges: 0, byLabel: {} }),
+    ensureIndexes: async () => {},
+  } as unknown as FalkorDBGraphStore;
+}
+
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+
+async function main(): Promise<void> {
+  const { command, subcommand, flags } = parseArgs(process.argv);
+
+  if (!command || command === '--help' || command === 'help' || command === '-h') {
+    printHelp();
+    process.exit(0);
+  }
+
+  switch (command) {
+    case 'init':
+      await cmdInit(flags);
+      break;
+
+    case 'register':
+      await cmdRegister(flags);
+      break;
+
+    case 'index':
+      await cmdIndex(flags);
+      break;
+
+    case 'status':
+      cmdStatus(flags);
+      break;
+
+    case 'knowledge':
+      if (!subcommand) {
+        printError("knowledge requires a subcommand: list, search, sync, or migrate");
+      }
+      cmdKnowledge(subcommand, flags);
+      break;
+
+    case 'repos':
+      if (!subcommand) {
+        printError("repos requires a subcommand: list, info, or remove");
+      }
+      cmdRepos(subcommand, flags);
+      break;
+
+    default:
+      console.error(`Unknown command: '${command}'`);
+      printHelp();
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(`forge CLI error: ${String(err)}`);
+  process.exit(1);
+});