codetrap 0.1.2 → 0.1.4

package/src/lib/scope-context.ts

@@ -0,0 +1,118 @@
+import { openGlobal, openProject } from "../db/connection";
+import { TrapRepository } from "../db/repository";
+import { CODETRAP_DIR, TRAPS_DB_FILE } from "./constants";
+import type { Scope } from "./constants";
+import type { EmbeddingProvider } from "./embedder";
+import { findProjectRoot, getGlobalDB, resolveScopePath } from "./scope";
+import { ScopePathResolver } from "./scope-path";
+
+const scopePath = new ScopePathResolver();
+
+export type ScopeContext = {
+  cwd: string;
+  project_root: string | null;
+  project_db: string | null;
+  global_db: string;
+};
+
+export function createScopeContext(cwd = process.cwd()): ScopeContext {
+  const resolvedCwd = resolveScopePath(cwd);
+  const projectRoot = findProjectRoot(resolvedCwd);
+  return {
+    cwd: resolvedCwd,
+    project_root: projectRoot,
+    project_db: projectRoot ? scopePath.join(projectRoot, CODETRAP_DIR, TRAPS_DB_FILE) : null,
+    global_db: getGlobalDB(),
+  };
+}
+
+export type ScopedRepository = {
+  scope: Scope;
+  repository: TrapRepository;
+};
+
+export class ScopedRepositoryContext {
+  private readonly context: ScopeContext;
+  private globalRepository?: TrapRepository;
+  private projectRepository?: TrapRepository;
+
+  constructor(cwd = process.cwd(), private readonly embedder?: EmbeddingProvider) {
+    this.context = createScopeContext(cwd);
+  }
+
+  hasProject(): boolean {
+    return this.context.project_root !== null;
+  }
+
+  projectRoot(): string | null {
+    return this.context.project_root;
+  }
+
+  repositoriesForRead(scope?: string): ScopedRepository[] {
+    const resolvedScope = optionalScope(scope);
+    if (resolvedScope) {
+      const entry = this.repositoryEntry(resolvedScope);
+      return entry ? [entry] : [];
+    }
+
+    const repositories: ScopedRepository[] = [];
+    const project = this.repositoryEntry("project");
+    if (project) repositories.push(project);
+    repositories.push({ scope: "global", repository: this.globalRepo() });
+    return repositories;
+  }
+
+  repositoriesForWrite(scope?: string): ScopedRepository[] {
+    return this.repositoriesForRead(scope);
+  }
+
+  repositoryFor(scope: Scope): TrapRepository {
+    const entry = this.repositoryEntry(scope);
+    if (!entry) {
+      throw new Error("Not in a project. Run 'codetrap init' first, or use --scope global.");
+    }
+    return entry.repository;
+  }
+
+  repositoryEntry(scope: Scope): ScopedRepository | null {
+    if (scope === "project") {
+      return this.context.project_root ? { scope, repository: this.projectRepo() } : null;
+    }
+    return { scope, repository: this.globalRepo() };
+  }
+
+  private projectRepo(): TrapRepository {
+    const projectRoot = this.context.project_root;
+    if (!projectRoot) {
+      throw new Error("Not in a project. Run 'codetrap init' first, or use --scope global.");
+    }
+    if (!this.projectRepository) {
+      this.projectRepository = new TrapRepository(openProject(projectRoot), this.embedder);
+    }
+    return this.projectRepository;
+  }
+
+  private globalRepo(): TrapRepository {
+    if (!this.globalRepository) {
+      this.globalRepository = new TrapRepository(openGlobal(), this.embedder);
+    }
+    return this.globalRepository;
+  }
+}
+
+export function normalizeScope(scope: string): Scope {
+  if (scope === "project" || scope === "global") return scope;
+  throw new Error(`Invalid scope: ${scope}`);
+}
+
+export function optionalScope(scope?: string): Scope | null {
+  if (!scope) return null;
+  return normalizeScope(scope);
+}
+
+export function storeForScopeContext<T extends { forCwd(cwd: string): T }>(store: T, cwd?: unknown): T {
+  if (typeof cwd === "string" && cwd.trim() !== "") {
+    return store.forCwd(cwd);
+  }
+  return store;
+}

package/src/lib/scope-maintenance.ts

@@ -0,0 +1,71 @@
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { TrapRepository } from "../db/repository";
+import { CODETRAP_DIR, TRAPS_DB_FILE } from "./constants";
+import { ScopePathResolver } from "./scope-path";
+
+const scopePath = new ScopePathResolver();
+
+export type ScopeMaintenanceCommand = "repair-scope" | "migrate-project";
+
+export type ScopeMaintenancePaths = {
+  command: ScopeMaintenanceCommand;
+  fromProjectPath: string;
+  toProjectPath: string;
+  sourceDb: string;
+  destinationDb: string;
+};
+
+export function buildScopeMaintenancePaths(input: {
+  command: ScopeMaintenanceCommand;
+  fromProjectPath: string;
+  toProjectPath: string;
+}): ScopeMaintenancePaths {
+  return {
+    command: input.command,
+    fromProjectPath: input.fromProjectPath,
+    toProjectPath: input.toProjectPath,
+    sourceDb: projectDbPath(input.fromProjectPath),
+    destinationDb: projectDbPath(input.toProjectPath),
+  };
+}
+
+export function validateScopeMaintenancePaths(input: ScopeMaintenancePaths): void {
+  if (input.command === "migrate-project" && scopePath.same(input.fromProjectPath, input.toProjectPath)) {
+    throw new Error("--from-project-path and --to-project-path must be different.");
+  }
+  if (scopePath.same(input.sourceDb, input.destinationDb)) {
+    throw new Error("Source and destination database paths are the same.");
+  }
+  if (!existsSync(scopePath.join(input.toProjectPath, CODETRAP_DIR))) {
+    throw new Error(`Destination project is not initialized: ${input.toProjectPath}. Run 'codetrap init' first.`);
+  }
+}
+
+export function projectDbPath(projectPath: string): string {
+  return scopePath.join(projectPath, CODETRAP_DIR, TRAPS_DB_FILE);
+}
+
+export function withReadOnlyScopeRepository<T>(dbPath: string, callback: (repository: TrapRepository) => T): T {
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    return callback(new TrapRepository(db));
+  } finally {
+    db.close();
+  }
+}
+
+export function backupScopeDatabase(dbPath: string, label: string): string {
+  const backupDir = join(dirname(dbPath), "backups");
+  mkdirSync(backupDir, { recursive: true });
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupPath = join(backupDir, `${basename(dbPath)}.${label}.${timestamp}.backup`);
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    writeFileSync(backupPath, db.serialize());
+  } finally {
+    db.close();
+  }
+  return backupPath;
+}

package/src/lib/scope-migration.ts

@@ -0,0 +1,315 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { openDatabase } from "../db/connection";
+import { TrapRepository } from "../db/repository";
+import type { TrapExportRecord } from "../domain/trap";
+import { findProjectRoot, resolveScopePath } from "./scope";
+import {
+  backupScopeDatabase,
+  buildScopeMaintenancePaths,
+  validateScopeMaintenancePaths,
+  withReadOnlyScopeRepository,
+  type ScopeMaintenanceCommand,
+} from "./scope-maintenance";
+import {
+  deleteTransferredSourceTraps,
+  importProjectTrapTransfer,
+  type TrapTransferMapping,
+} from "./trap-transfer";
+
+export type ScopeMigrationCommand = ScopeMaintenanceCommand;
+export type ScopeMigrationMode = "dry-run" | "apply";
+
+export type ScopeMigrationCandidate = {
+  id: number;
+  title: string;
+  category: string;
+  severity: string;
+  status: string;
+  project_path: string | null;
+};
+
+export type ScopeMigrationCounts = {
+  source_before: number;
+  source_after: number;
+  destination_before: number;
+  destination_after: number;
+  candidates: number;
+  moved: number;
+};
+
+export type ScopeMigrationBackups = {
+  source_db: string | null;
+  destination_db: string | null;
+};
+
+export type ScopeMigrationResult = {
+  command: ScopeMigrationCommand;
+  mode: ScopeMigrationMode;
+  from_project_path: string;
+  to_project_path: string;
+  source_db: string;
+  destination_db: string;
+  source_db_exists: boolean;
+  destination_db_exists: boolean;
+  candidates: ScopeMigrationCandidate[];
+  moved: TrapTransferMapping[];
+  backups: ScopeMigrationBackups;
+  counts: ScopeMigrationCounts;
+  next_action: { command: string } | null;
+};
+
+export type ScopeMigrationOptions = {
+  command: ScopeMigrationCommand;
+  cwd?: string;
+  fromProjectPath?: string;
+  toProjectPath?: string;
+  apply?: boolean;
+};
+
+type ResolvedScopeMigration = {
+  command: ScopeMigrationCommand;
+  mode: ScopeMigrationMode;
+  apply: boolean;
+  fromProjectPath: string;
+  toProjectPath: string;
+  sourceDb: string;
+  destinationDb: string;
+};
+
+type ScopeMigrationPlan = ResolvedScopeMigration & {
+  sourceDbExists: boolean;
+  destinationDbExists: boolean;
+  records: TrapExportRecord[];
+  sourceBefore: number;
+  destinationBefore: number;
+};
+
+type ScopeMigrationApplyResult = {
+  moved: TrapTransferMapping[];
+  backups: ScopeMigrationBackups;
+  sourceAfter: number;
+  destinationAfter: number;
+};
+
+export function runScopeMigration(options: ScopeMigrationOptions): ScopeMigrationResult {
+  const plan = buildScopeMigrationPlan(options);
+
+  if (!plan.apply || plan.records.length === 0) {
+    return buildScopeMigrationResult(plan, {
+      moved: [],
+      backups: { source_db: null, destination_db: null },
+      sourceAfter: plan.sourceBefore,
+      destinationAfter: plan.destinationBefore,
+    });
+  }
+
+  return buildScopeMigrationResult(plan, applyScopeMigrationPlan(plan));
+}
+
+export function formatScopeMigrationText(result: ScopeMigrationResult): string {
+  const lines = [
+    `${result.command} ${result.mode}`,
+    `from_project_path: ${result.from_project_path}`,
+    `to_project_path: ${result.to_project_path}`,
+    `source_db: ${result.source_db}${result.source_db_exists ? "" : " (missing)"}`,
+    `destination_db: ${result.destination_db}${result.destination_db_exists ? "" : " (missing)"}`,
+    `candidates: ${result.counts.candidates}`,
+  ];
+
+  if (result.candidates.length > 0) {
+    lines.push("candidate traps:");
+    lines.push(...result.candidates.map((trap) =>
+      `  #${trap.id} [${trap.severity}] [${trap.category}] [${trap.status}] ${trap.title}`
+    ));
+  }
+
+  if (result.mode === "apply") {
+    lines.push(`moved: ${result.counts.moved}`);
+    if (result.backups.source_db || result.backups.destination_db) {
+      lines.push("backups:");
+      if (result.backups.source_db) lines.push(`  source_db: ${result.backups.source_db}`);
+      if (result.backups.destination_db) lines.push(`  destination_db: ${result.backups.destination_db}`);
+    }
+    if (result.moved.length > 0) {
+      lines.push("id mapping:");
+      lines.push(...result.moved.map((item) =>
+        `  #${item.source_id} -> #${item.destination_id} ${item.title}`
+      ));
+    }
+  }
+
+  lines.push(
+    `source_count: ${result.counts.source_before} -> ${result.counts.source_after}`,
+    `destination_count: ${result.counts.destination_before} -> ${result.counts.destination_after}`
+  );
+
+  if (result.next_action) {
+    lines.push(`Next: ${result.next_action.command}`);
+  }
+  if (result.candidates.length === 0) {
+    lines.push("No matching project traps found.");
+  }
+  return lines.join("\n");
+}
+
+function buildScopeMigrationPlan(options: ScopeMigrationOptions): ScopeMigrationPlan {
+  const resolved = resolveScopeMigrationOptions(options);
+  validateScopeMaintenancePaths(resolved);
+  const sourceDbExists = existsSync(resolved.sourceDb);
+  const destinationDbExists = existsSync(resolved.destinationDb);
+  const records = sourceDbExists
+    ? withReadOnlyScopeRepository(resolved.sourceDb, (repository) =>
+        repository.exportProjectTrapsByPath(resolved.fromProjectPath)
+      )
+    : [];
+  const destinationBefore = destinationDbExists
+    ? withReadOnlyScopeRepository(resolved.destinationDb, (repository) =>
+        repository.countProjectTrapsByPath(resolved.toProjectPath)
+      )
+    : 0;
+
+  return {
+    ...resolved,
+    sourceDbExists,
+    destinationDbExists,
+    records,
+    sourceBefore: records.length,
+    destinationBefore,
+  };
+}
+
+function applyScopeMigrationPlan(plan: ScopeMigrationPlan): ScopeMigrationApplyResult {
+  const backups = {
+    source_db: backupScopeDatabase(plan.sourceDb, "source"),
+    destination_db: plan.destinationDbExists ? backupScopeDatabase(plan.destinationDb, "destination") : null,
+  };
+
+  const applyResult = applyScopeMigration(
+    plan.sourceDb,
+    plan.destinationDb,
+    plan.fromProjectPath,
+    plan.toProjectPath
+  );
+
+  return {
+    moved: applyResult.moved,
+    backups,
+    sourceAfter: applyResult.sourceAfter,
+    destinationAfter: applyResult.destinationAfter,
+  };
+}
+
+function resolveScopeMigrationOptions(options: ScopeMigrationOptions): ResolvedScopeMigration {
+  const cwd = resolveScopePath(options.cwd ?? process.cwd());
+  const projectRoot = findProjectRoot(cwd);
+  const fromProjectPath = resolveScopePath(options.fromProjectPath ?? homedir());
+  const rawToProjectPath = options.toProjectPath ?? projectRoot;
+
+  if (!rawToProjectPath) {
+    throw new Error("Destination project not found. Run 'codetrap init' first, or pass --to-project-path.");
+  }
+  const toProjectPath = resolveScopePath(rawToProjectPath);
+
+  return {
+    ...buildScopeMaintenancePaths({
+      command: options.command,
+      fromProjectPath,
+      toProjectPath,
+    }),
+    mode: options.apply ? "apply" : "dry-run",
+    apply: options.apply === true,
+  };
+}
+
+function applyScopeMigration(
+  sourceDbPath: string,
+  destinationDbPath: string,
+  fromProjectPath: string,
+  toProjectPath: string
+): { moved: TrapTransferMapping[]; sourceAfter: number; destinationAfter: number } {
+  const sourceDb = openDatabase(sourceDbPath);
+  const destinationDb = openDatabase(destinationDbPath);
+  try {
+    const sourceRepository = new TrapRepository(sourceDb);
+    const destinationRepository = new TrapRepository(destinationDb);
+    const records = sourceRepository.exportProjectTrapsByPath(fromProjectPath);
+    const moved = importProjectTrapTransfer(destinationRepository, records, toProjectPath);
+    const deleted = deleteTransferredSourceTraps(sourceRepository, records);
+    if (deleted !== records.length) {
+      throw new Error(`Expected to delete ${records.length} source traps, deleted ${deleted}.`);
+    }
+
+    return {
+      moved,
+      sourceAfter: sourceRepository.countProjectTrapsByPath(fromProjectPath),
+      destinationAfter: destinationRepository.countProjectTrapsByPath(toProjectPath),
+    };
+  } finally {
+    sourceDb.close();
+    destinationDb.close();
+  }
+}
+
+function buildScopeMigrationResult(
+  plan: ScopeMigrationPlan,
+  applied: ScopeMigrationApplyResult
+): ScopeMigrationResult {
+  const candidates = plan.records.map(toCandidate);
+  return {
+    command: plan.command,
+    mode: plan.mode,
+    from_project_path: plan.fromProjectPath,
+    to_project_path: plan.toProjectPath,
+    source_db: plan.sourceDb,
+    destination_db: plan.destinationDb,
+    source_db_exists: plan.sourceDbExists,
+    destination_db_exists: plan.destinationDbExists,
+    candidates,
+    moved: applied.moved,
+    backups: applied.backups,
+    counts: {
+      source_before: plan.sourceBefore,
+      source_after: applied.sourceAfter,
+      destination_before: plan.destinationBefore,
+      destination_after: applied.destinationAfter,
+      candidates: candidates.length,
+      moved: applied.moved.length,
+    },
+    next_action: plan.mode === "dry-run" && candidates.length > 0
+      ? { command: buildApplyCommand(plan.command, plan.fromProjectPath, plan.toProjectPath) }
+      : null,
+  };
+}
+
+function toCandidate(record: TrapExportRecord): ScopeMigrationCandidate {
+  return {
+    id: record.id,
+    title: record.title,
+    category: record.category,
+    severity: record.severity,
+    status: record.status,
+    project_path: record.project_path,
+  };
+}
+
+function buildApplyCommand(
+  command: ScopeMigrationCommand,
+  fromProjectPath: string,
+  toProjectPath: string
+): string {
+  return [
+    "codetrap",
+    command,
+    "--from-project-path",
+    shellQuote(fromProjectPath),
+    "--to-project-path",
+    shellQuote(toProjectPath),
+    "--apply",
+    "--json",
+  ].join(" ");
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}

package/src/lib/scope-path.ts

@@ -0,0 +1,99 @@
+import { existsSync, realpathSync } from "node:fs";
+import { posix, win32 } from "node:path";
+
+export type ScopePathFlavor = "posix" | "win32";
+
+export type ScopePathFs = {
+  exists(path: string): boolean;
+  realpath(path: string): string;
+};
+
+export type ScopePathResolverOptions = {
+  fs?: ScopePathFs;
+  platform?: NodeJS.Platform;
+};
+
+const nodeFs: ScopePathFs = {
+  exists: existsSync,
+  realpath: realpathSync,
+};
+
+export class ScopePathResolver {
+  private readonly fs: ScopePathFs;
+  private readonly platform: NodeJS.Platform;
+
+  constructor(options: ScopePathResolverOptions = {}) {
+    this.fs = options.fs ?? nodeFs;
+    this.platform = options.platform ?? process.platform;
+  }
+
+  resolve(path: string, relatedPath = path): string {
+    return this.resolveWithFlavor(path, this.flavorFor(path, relatedPath));
+  }
+
+  canonical(path: string, relatedPath = path): string {
+    const flavor = this.flavorFor(path, relatedPath);
+    const resolved = this.resolveWithFlavor(path, flavor);
+    const real = this.fs.exists(resolved) ? this.fs.realpath(resolved) : resolved;
+    const normalized = pathApi(flavor).normalize(real);
+    return flavor === "win32" ? normalized.toLowerCase() : normalized;
+  }
+
+  same(left: string, right: string): boolean {
+    const flavor = this.flavorFor(left, right);
+    return this.canonicalWithFlavor(left, flavor) === this.canonicalWithFlavor(right, flavor);
+  }
+
+  join(base: string, ...segments: string[]): string {
+    return pathApi(this.flavorFor(base)).join(base, ...segments);
+  }
+
+  exists(path: string): boolean {
+    return this.fs.exists(path);
+  }
+
+  dirname(path: string): string {
+    return pathApi(this.flavorFor(path)).dirname(path);
+  }
+
+  flavorFor(...paths: string[]): ScopePathFlavor {
+    if (this.platform === "win32") return "win32";
+    return paths.some((path) => isWindowsAbsolutePath(path) || isMsysAbsolutePath(path)) ? "win32" : "posix";
+  }
+
+  private canonicalWithFlavor(path: string, flavor: ScopePathFlavor): string {
+    const resolved = this.resolveWithFlavor(path, flavor);
+    const real = this.fs.exists(resolved) ? this.fs.realpath(resolved) : resolved;
+    const normalized = pathApi(flavor).normalize(real);
+    return flavor === "win32" ? normalized.toLowerCase() : normalized;
+  }
+
+  private resolveWithFlavor(path: string, flavor: ScopePathFlavor): string {
+    return pathApi(flavor).resolve(flavor === "win32" ? msysToWindowsPath(path) : path);
+  }
+}
+
+export const defaultScopePathResolver = new ScopePathResolver();
+
+export function resolveScopePath(path: string, relatedPath = path): string {
+  return defaultScopePathResolver.resolve(path, relatedPath);
+}
+
+function pathApi(flavor: ScopePathFlavor): typeof posix {
+  return flavor === "win32" ? win32 : posix;
+}
+
+function msysToWindowsPath(path: string): string {
+  const match = path.match(/^\/([a-zA-Z])(?:\/(.*))?$/);
+  if (!match) return path;
+  const [, drive, rest = ""] = match;
+  return `${drive.toUpperCase()}:\\${rest.replaceAll("/", "\\")}`;
+}
+
+function isWindowsAbsolutePath(path: string): boolean {
+  return /^[a-zA-Z]:[\\/]/.test(path) || /^\\\\/.test(path);
+}
+
+function isMsysAbsolutePath(path: string): boolean {
+  return /^\/[a-zA-Z](?:\/|$)/.test(path);
+}

package/src/lib/scope.ts

@@ -1,32 +1,37 @@
 import { existsSync, mkdirSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { CODETRAP_DIR, TRAPS_DB_FILE } from "./constants";
+import { defaultScopePathResolver, resolveScopePath, ScopePathResolver } from "./scope-path";
+
+export { resolveScopePath, ScopePathResolver } from "./scope-path";
 
 export function getGlobalDir(): string {
-  const dir = join(homedir(), CODETRAP_DIR);
+  const dir = defaultScopePathResolver.join(homedir(), CODETRAP_DIR);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   return dir;
 }
 
 export function getGlobalDB(): string {
-  return join(getGlobalDir(), TRAPS_DB_FILE);
+  return defaultScopePathResolver.join(getGlobalDir(), TRAPS_DB_FILE);
 }
 
-export function findProjectRoot(cwd: string, homeDir = homedir()): string | null {
-  let dir = resolve(cwd);
-  const home = resolve(homeDir);
+export function findProjectRoot(
+  cwd: string,
+  homeDir = homedir(),
+  resolver: ScopePathResolver = defaultScopePathResolver
+): string | null {
+  let dir = resolver.resolve(cwd, homeDir);
   while (true) {
-    if (dir === home) return null;
-    if (existsSync(join(dir, CODETRAP_DIR))) return dir;
-    const parent = dirname(dir);
+    if (resolver.same(dir, homeDir)) return null;
+    if (resolver.exists(resolver.join(dir, CODETRAP_DIR))) return dir;
+    const parent = resolver.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
 
 export function getProjectDB(root: string): string {
-  const dir = join(root, CODETRAP_DIR);
+  const dir = defaultScopePathResolver.join(root, CODETRAP_DIR);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  return join(dir, TRAPS_DB_FILE);
+  return defaultScopePathResolver.join(dir, TRAPS_DB_FILE);
 }

package/src/lib/search-normalizer.ts

@@ -18,6 +18,9 @@ export type SearchTextFields = {
   tags?: string | string[];
   before_code?: string | null;
   after_code?: string | null;
+  path_globs?: string | string[] | null;
+  module?: string | null;
+  owner?: string | null;
 };
 
 export const SEARCH_TEXT_FIELD_NAMES = [
@@ -28,6 +31,9 @@ export const SEARCH_TEXT_FIELD_NAMES = [
   "tags",
   "before_code",
   "after_code",
+  "path_globs",
+  "module",
+  "owner",
 ] as const;
 
 export function bigramCJK(input: string): string[] {