ndomo 0.1.0 → 0.2.1

package/src/worktrees/manager.ts

@@ -1,236 +0,0 @@
-/**
- * Git worktree manager for isolated coding lanes.
- *
- * Provides CRUD operations for git worktrees with persistent state tracking.
- * All git operations use async exec to avoid blocking the event loop.
- *
- * @module worktrees/manager
- */
-
-import { exec as execCb } from "node:child_process";
-import { existsSync } from "node:fs";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { promisify } from "node:util";
-
-const exec = promisify(execCb);
-
-// ─── Types ───────────────────────────────────────────────────────────────────
-
-export interface Worktree {
-  slug: string;
-  branch: string;
-  path: string;
-  createdAt: number;
-  status: "active" | "merged" | "abandoned";
-  agent?: string | undefined;
-  description?: string | undefined;
-}
-
-export interface WorktreeState {
-  worktrees: Worktree[];
-  updatedAt: number;
-}
-
-// ─── Constants ───────────────────────────────────────────────────────────────
-
-const STATE_FILE = ".slim/worktrees.json";
-const WORKTREE_DIR = ".slim/worktrees";
-
-/** Regex for valid slug/branch names — alphanumeric, hyphens, underscores, slashes */
-const SAFE_NAME_RE = /^[a-zA-Z0-9_\-/]+$/;
-
-// ─── Validation ──────────────────────────────────────────────────────────────
-
-/**
- * Validate that a string is safe for use in git commands.
- * Prevents shell injection via slug or branch parameters.
- */
-function assertSafeName(value: string, label: string): void {
-  if (!value || typeof value !== "string") {
-    throw new Error(`${label} must be a non-empty string`);
-  }
-  if (!SAFE_NAME_RE.test(value)) {
-    throw new Error(
-      `${label} contains invalid characters: "${value}". Only alphanumeric, hyphens, underscores, and slashes allowed.`,
-    );
-  }
-  if (value.startsWith("-")) {
-    throw new Error(`${label} must not start with a hyphen`);
-  }
-}
-
-// ─── State Persistence ───────────────────────────────────────────────────────
-
-/**
- * Load worktree state from disk.
- * Returns empty state if file doesn't exist or is malformed.
- */
-export async function loadState(rootDir: string): Promise<WorktreeState> {
-  const statePath = join(rootDir, STATE_FILE);
-  try {
-    const raw = await readFile(statePath, "utf-8");
-    const parsed = JSON.parse(raw) as WorktreeState;
-    // Defensive: ensure worktrees array exists
-    if (!Array.isArray(parsed.worktrees)) {
-      return { worktrees: [], updatedAt: Date.now() };
-    }
-    return parsed;
-  } catch {
-    return { worktrees: [], updatedAt: Date.now() };
-  }
-}
-
-/**
- * Save worktree state to disk.
- * Creates .slim/ directory if needed.
- */
-export async function saveState(rootDir: string, state: WorktreeState): Promise<void> {
-  const slimDir = join(rootDir, ".slim");
-  if (!existsSync(slimDir)) {
-    await mkdir(slimDir, { recursive: true });
-  }
-  state.updatedAt = Date.now();
-  await writeFile(join(rootDir, STATE_FILE), JSON.stringify(state, null, 2));
-}
-
-// ─── Worktree Operations ─────────────────────────────────────────────────────
-
-/**
- * Create a new git worktree.
- *
- * @param rootDir - repository root directory
- * @param slug - short identifier (e.g., "auth-refactor", "fix-login")
- * @param branch - git branch name (created from current HEAD if doesn't exist)
- * @param agent - which agent will work in this worktree (optional)
- * @param description - human-readable description (optional)
- * @returns path to the new worktree
- * @throws if slug contains unsafe characters or worktree already exists
- */
-export async function createWorktree(
-  rootDir: string,
-  slug: string,
-  branch: string,
-  agent?: string,
-  description?: string,
-): Promise<string> {
-  assertSafeName(slug, "slug");
-  assertSafeName(branch, "branch");
-
-  const worktreePath = join(rootDir, WORKTREE_DIR, slug);
-
-  // Check if already exists
-  const state = await loadState(rootDir);
-  const existing = state.worktrees.find((w) => w.slug === slug && w.status === "active");
-  if (existing) {
-    throw new Error(`Worktree '${slug}' already exists at ${existing.path}`);
-  }
-
-  // Create parent directory
-  await mkdir(join(rootDir, WORKTREE_DIR), { recursive: true });
-
-  // Git worktree add — try creating new branch first, fall back to existing branch
-  try {
-    await exec(`git worktree add -b ${branch} ${worktreePath}`, { cwd: rootDir });
-  } catch {
-    // Branch might already exist
-    await exec(`git worktree add ${worktreePath} ${branch}`, { cwd: rootDir });
-  }
-
-  // Update state
-  state.worktrees.push({
-    slug,
-    branch,
-    path: worktreePath,
-    createdAt: Date.now(),
-    status: "active",
-    agent,
-    description,
-  });
-  await saveState(rootDir, state);
-
-  return worktreePath;
-}
-
-/**
- * Remove a worktree.
- *
- * @param rootDir - repository root directory
- * @param slug - worktree identifier
- * @param abandon - if true, marks as abandoned instead of merged
- * @throws if no active worktree found with the given slug
- */
-export async function removeWorktree(
-  rootDir: string,
-  slug: string,
-  abandon = false,
-): Promise<void> {
-  assertSafeName(slug, "slug");
-
-  const state = await loadState(rootDir);
-  const wt = state.worktrees.find((w) => w.slug === slug && w.status === "active");
-  if (!wt) {
-    throw new Error(`No active worktree found with slug '${slug}'`);
-  }
-
-  // Remove git worktree, force if regular remove fails
-  try {
-    await exec(`git worktree remove ${wt.path}`, { cwd: rootDir });
-  } catch {
-    await exec(`git worktree remove --force ${wt.path}`, { cwd: rootDir });
-  }
-
-  wt.status = abandon ? "abandoned" : "merged";
-  await saveState(rootDir, state);
-}
-
-/**
- * List all active worktrees.
- */
-export async function listActive(rootDir: string): Promise<Worktree[]> {
-  const state = await loadState(rootDir);
-  return state.worktrees.filter((w) => w.status === "active");
-}
-
-/**
- * Get a specific worktree by slug.
- * Returns undefined if not found.
- */
-export async function getWorktree(rootDir: string, slug: string): Promise<Worktree | undefined> {
-  assertSafeName(slug, "slug");
-
-  const state = await loadState(rootDir);
-  return state.worktrees.find((w) => w.slug === slug);
-}
-
-/**
- * Cleanup all abandoned/merged worktrees older than maxAge (ms).
- *
- * @param rootDir - repository root directory
- * @param maxAge - max age in milliseconds (default: 7 days)
- * @returns list of removed worktree slugs
- */
-export async function cleanup(
-  rootDir: string,
-  maxAge: number = 7 * 24 * 60 * 60 * 1000,
-): Promise<string[]> {
-  const state = await loadState(rootDir);
-  const now = Date.now();
-  const removed: string[] = [];
-
-  for (const wt of state.worktrees) {
-    if (wt.status !== "active" && now - wt.createdAt > maxAge) {
-      // Remove directory if it still exists
-      if (existsSync(wt.path)) {
-        await rm(wt.path, { recursive: true, force: true });
-      }
-      removed.push(wt.slug);
-    }
-  }
-
-  // Filter out removed entries
-  state.worktrees = state.worktrees.filter((w) => !removed.includes(w.slug));
-  await saveState(rootDir, state);
-
-  return removed;
-}

package/src/worktrees/state.ts

@@ -1,87 +0,0 @@
-/**
- * Worktree integrity verification.
- *
- * Checks that active worktrees have valid directories, branches,
- * and are properly registered with git.
- *
- * @module worktrees/state
- */
-
-import { exec as execCb } from "node:child_process";
-import { existsSync } from "node:fs";
-import { promisify } from "node:util";
-import type { Worktree, WorktreeState } from "./manager.ts";
-import { loadState } from "./manager.ts";
-
-const exec = promisify(execCb);
-
-export type { Worktree, WorktreeState };
-
-// ─── Types ───────────────────────────────────────────────────────────────────
-
-export interface IntegrityReport {
-  slug: string;
-  pathExists: boolean;
-  branchValid: boolean;
-  gitWorktreeValid: boolean;
-  issues: string[];
-}
-
-// ─── Integrity Checks ────────────────────────────────────────────────────────
-
-/**
- * Verify integrity of all active worktrees.
- *
- * Checks per worktree:
- * 1. Directory exists on disk
- * 2. Branch exists in git
- * 3. Worktree is registered in `git worktree list`
- *
- * @param rootDir - repository root directory
- * @returns array of integrity reports (only for active worktrees)
- */
-export async function verifyIntegrity(rootDir: string): Promise<IntegrityReport[]> {
-  const state = await loadState(rootDir);
-  const reports: IntegrityReport[] = [];
-
-  // Get git worktree list once (not per-worktree)
-  let gitWorktreeOutput = "";
-  try {
-    const { stdout } = await exec("git worktree list", { cwd: rootDir });
-    gitWorktreeOutput = stdout;
-  } catch {
-    // If this fails, all worktrees will report the issue
-  }
-
-  for (const wt of state.worktrees) {
-    if (wt.status !== "active") continue;
-
-    const issues: string[] = [];
-    const pathExists = existsSync(wt.path);
-
-    // Check if worktree path appears in git worktree list
-    const gitWorktreeValid = gitWorktreeOutput.includes(wt.path);
-
-    // Check branch exists
-    let branchValid = false;
-    try {
-      await exec(`git rev-parse --verify ${wt.branch}`, { cwd: rootDir });
-      branchValid = true;
-    } catch {
-      issues.push(`branch '${wt.branch}' not found`);
-    }
-
-    if (!pathExists) issues.push(`directory '${wt.path}' missing`);
-    if (!gitWorktreeValid) issues.push("worktree not registered with git");
-
-    reports.push({
-      slug: wt.slug,
-      pathExists,
-      branchValid,
-      gitWorktreeValid,
-      issues,
-    });
-  }
-
-  return reports;
-}

package/tests/integration/ranger-flow.test.ts

@@ -1,257 +0,0 @@
-/**
- * Integration test — analyses (ranger) full flow end-to-end.
- *
- * Exercises create/get/list/search/update/archive/link/unlink
- * using direct DB + CRUD calls (no tool runtime, no mocks).
- * Each test gets a fresh in-memory DB with full schema via runMigrations.
- */
-
-import { Database } from "bun:sqlite";
-import { beforeEach, describe, expect, test } from "bun:test";
-import {
-  archiveAnalysis,
-  createAnalysis,
-  getAnalysis,
-  getAnalysisBySlug,
-  linkAnalysisToPlan,
-  listAnalyses,
-  searchAnalyses,
-  unlinkAnalysisFromPlan,
-  updateAnalysis,
-} from "../../src/db/analyses.ts";
-import { createPlan } from "../../src/db/plans.ts";
-import { runMigrations } from "../../src/db/migrations.ts";
-
-let db: Database;
-
-/** Minimal plan stub for FK-dependent tests. */
-function makePlan(id = "plan-1", slug = "test-plan") {
-  return createPlan(db, {
-    id,
-    slug,
-    title: "Test Plan",
-    status: "draft",
-    priority: 1,
-    overview: "test overview",
-    complexity: 3,
-    createdBy: "test",
-    updatedBy: "test",
-    sessionId: null,
-    approvedAt: null,
-    completedAt: null,
-    approach: null,
-    sourceSessionId: null,
-    sourceMessageId: null,
-    category: null,
-    metadata: {},
-    archivedAt: null,
-  });
-}
-
-beforeEach(() => {
-  db = new Database(":memory:");
-  db.exec("PRAGMA foreign_keys = ON");
-  runMigrations(db);
-});
-
-describe("analyses integration — ranger flow", () => {
-  test("create + get roundtrips all fields", () => {
-    const created = createAnalysis(db, {
-      slug: "auth-review",
-      title: "Auth Module Review",
-      projectPath: "/home/user/project",
-      summary: "Reviewed auth module for vulnerabilities",
-      findingsJson: JSON.stringify([{ severity: "high", desc: "weak hash" }]),
-      agent: "ranger",
-    });
-
-    expect(created.id).toBeTruthy();
-    expect(created.slug).toBe("auth-review");
-    expect(created.title).toBe("Auth Module Review");
-    expect(created.projectPath).toBe("/home/user/project");
-    expect(created.summary).toBe("Reviewed auth module for vulnerabilities");
-    expect(created.agent).toBe("ranger");
-    expect(created.archivedAt).toBeNull();
-
-    const findings = JSON.parse(created.findingsJson);
-    expect(findings).toHaveLength(1);
-    expect(findings[0].severity).toBe("high");
-
-    // get by id returns same data
-    const fetched = getAnalysis(db, created.id);
-    expect(fetched).not.toBeNull();
-    expect(fetched!.id).toBe(created.id);
-    expect(fetched!.slug).toBe(created.slug);
-    expect(fetched!.title).toBe(created.title);
-  });
-
-  test("agent defaults to 'ranger' when omitted", () => {
-    const a = createAnalysis(db, {
-      slug: "default-agent",
-      title: "Default Agent Test",
-      projectPath: "/p",
-    });
-    expect(a.agent).toBe("ranger");
-  });
-
-  test("slug uniqueness — same slug + projectPath throws", () => {
-    createAnalysis(db, {
-      slug: "dup-slug",
-      title: "First",
-      projectPath: "/p",
-    });
-
-    expect(() =>
-      createAnalysis(db, {
-        slug: "dup-slug",
-        title: "Second",
-        projectPath: "/p",
-      }),
-    ).toThrow(/already exists/);
-  });
-
-  test("same slug different projectPath is OK", () => {
-    createAnalysis(db, { slug: "shared-slug", title: "A", projectPath: "/p1" });
-    const b = createAnalysis(db, { slug: "shared-slug", title: "B", projectPath: "/p2" });
-    expect(b.slug).toBe("shared-slug");
-    expect(b.projectPath).toBe("/p2");
-  });
-
-  test("list filters by agent, sourcePlanId, archived", () => {
-    const plan = makePlan();
-    createAnalysis(db, { slug: "a1", title: "Alpha", projectPath: "/p", agent: "ranger" });
-    createAnalysis(db, { slug: "a2", title: "Beta", projectPath: "/p", agent: "sage" });
-    createAnalysis(db, { slug: "a3", title: "Gamma", projectPath: "/p", agent: "craftsman" });
-    const linked = getAnalysisBySlug(db, "a3", "/p")!;
-    linkAnalysisToPlan(db, linked.id, plan.id);
-
-    // filter by agent
-    const rangers = listAnalyses(db, { agent: "ranger" });
-    expect(rangers).toHaveLength(1);
-    expect(rangers[0].slug).toBe("a1");
-
-    // filter by sourcePlanId
-    const byPlan = listAnalyses(db, { sourcePlanId: plan.id });
-    expect(byPlan).toHaveLength(1);
-    expect(byPlan[0].slug).toBe("a3");
-
-    // archived filter
-    const all = listAnalyses(db, { archived: false });
-    expect(all.length).toBeGreaterThanOrEqual(3);
-
-    archiveAnalysis(db, linked.id);
-    const active = listAnalyses(db, { archived: false });
-    expect(active.find((a) => a.id === linked.id)).toBeUndefined();
-
-    const archived = listAnalyses(db, { archived: true });
-    expect(archived.find((a) => a.id === linked.id)).toBeDefined();
-  });
-
-  test("search FTS — finds matching analysis by title", () => {
-    createAnalysis(db, { slug: "s1", title: "Database Security Audit", projectPath: "/p" });
-    createAnalysis(db, { slug: "s2", title: "Frontend Performance Review", projectPath: "/p" });
-    createAnalysis(db, { slug: "s3", title: "API Authentication Analysis", projectPath: "/p" });
-
-    const results = searchAnalyses(db, "security");
-    expect(results).toHaveLength(1);
-    expect(results[0].slug).toBe("s1");
-  });
-
-  test("search FTS — finds matching analysis by summary", () => {
-    createAnalysis(db, {
-      slug: "s-summary",
-      title: "Generic Title",
-      projectPath: "/p",
-      summary: "Found critical XSS vulnerabilities in form handlers",
-    });
-
-    const results = searchAnalyses(db, "XSS vulnerabilities");
-    expect(results).toHaveLength(1);
-    expect(results[0].slug).toBe("s-summary");
-  });
-
-  test("update partial — only changed fields update + updated_at bumps", () => {
-    const a = createAnalysis(db, {
-      slug: "upd",
-      title: "Original Title",
-      projectPath: "/p",
-      summary: "original summary",
-    });
-
-    const updated = updateAnalysis(db, a.id, { title: "New Title" });
-    expect(updated.title).toBe("New Title");
-    expect(updated.summary).toBe("original summary"); // unchanged
-    expect(updated.slug).toBe("upd"); // unchanged
-    // updated_at is datetime('now') — same-second updates may have same value;
-    // just verify the field exists and is a string
-    expect(typeof updated.updatedAt).toBe("string");
-  });
-
-  test("archive + list excludes archived", () => {
-    const a = createAnalysis(db, { slug: "to-archive", title: "Archive Me", projectPath: "/p" });
-    expect(a.archivedAt).toBeNull();
-
-    const archived = archiveAnalysis(db, a.id);
-    expect(archived.archivedAt).toBeTruthy();
-
-    // default list excludes archived
-    const active = listAnalyses(db);
-    expect(active.find((x) => x.id === a.id)).toBeUndefined();
-
-    // getAnalysis excludes archived by default
-    expect(getAnalysis(db, a.id)).toBeNull();
-
-    // getAnalysis with includeArchived returns it
-    const found = getAnalysis(db, a.id, { includeArchived: true });
-    expect(found).not.toBeNull();
-    expect(found!.id).toBe(a.id);
-
-    // idempotent — archiving again is a no-op
-    const again = archiveAnalysis(db, a.id);
-    expect(again.archivedAt).toBe(archived.archivedAt);
-  });
-
-  test("linkAnalysisToPlan — sets sourcePlanId", () => {
-    const plan = makePlan();
-    const a = createAnalysis(db, { slug: "link-me", title: "Link Me", projectPath: "/p" });
-    expect(a.sourcePlanId).toBeNull();
-
-    const linked = linkAnalysisToPlan(db, a.id, plan.id);
-    expect(linked.sourcePlanId).toBe(plan.id);
-
-    // getAnalysisBySlug reflects the link
-    const bySlug = getAnalysisBySlug(db, "link-me", "/p");
-    expect(bySlug!.sourcePlanId).toBe(plan.id);
-  });
-
-  test("linkAnalysisToPlan — FK validation: non-existent plan throws", () => {
-    const a = createAnalysis(db, { slug: "no-fk", title: "No FK", projectPath: "/p" });
-    expect(() => linkAnalysisToPlan(db, a.id, "non-existent-plan-id")).toThrow(/not found/);
-  });
-
-  test("unlinkAnalysisFromPlan — sets sourcePlanId to null", () => {
-    const plan = makePlan();
-    const a = createAnalysis(db, { slug: "unlink", title: "Unlink", projectPath: "/p" });
-    linkAnalysisToPlan(db, a.id, plan.id);
-
-    const unlinked = unlinkAnalysisFromPlan(db, a.id);
-    expect(unlinked.sourcePlanId).toBeNull();
-
-    // idempotent — unlinking again is a no-op
-    const again = unlinkAnalysisFromPlan(db, a.id);
-    expect(again.sourcePlanId).toBeNull();
-  });
-
-  test("CASCADE plan deletion — sourcePlanId becomes NULL (ON DELETE SET NULL)", () => {
-    const plan = makePlan("plan-cascade", "cascade-plan");
-    const a = createAnalysis(db, { slug: "cascade", title: "Cascade", projectPath: "/p" });
-    linkAnalysisToPlan(db, a.id, plan.id);
-
-    // delete plan directly via SQL (simulates external deletion)
-    db.query("DELETE FROM plans WHERE id = ?").run("plan-cascade");
-
-    const after = getAnalysis(db, a.id);
-    expect(after).not.toBeNull();
-    expect(after!.sourcePlanId).toBeNull();
-  });
-});

package/tsconfig.json

@@ -1,31 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "lib": ["ES2022"],
-    "types": ["bun-types"],
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "noEmit": true,
-    "strict": true,
-    "noImplicitAny": true,
-    "strictNullChecks": true,
-    "strictFunctionTypes": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "exactOptionalPropertyTypes": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "paths": {
-      "@/*": ["./src/*"]
-    }
-  },
-  "include": ["src/**/*", "scripts/**/*", "build.ts"],
-  "exclude": ["node_modules", "dist", ".slim"]
-}