@deksden-com/dd-flow-cli 0.1.0

package/dist/services/projects.js

@@ -0,0 +1,286 @@
+import fs from "node:fs";
+import path from "node:path";
+import { formatFullId, isFullEntityId, isShortEntityId, parseFullEntityId, slugFromRoot } from "../domain/entity-ids.js";
+import { AppError } from "../shared/errors.js";
+import { projectRuntimeRoot, resolveProjectRoot } from "../storage/paths.js";
+import { appendAudit } from "./audit.js";
+import { activeCodexSessionBindingsForProject, activeFlowSessionBindingsForProject, codexHomeProfilesForProject, codexHookEventsForProject, hookStatusForProject } from "./hooks.js";
+import { dashboardMarkdownPath, globalDashboardMarkdownPath, readProjectConfig } from "./config.js";
+export function registerProject(context, input) {
+    const root = resolveProjectRoot(input.root);
+    const existing = findProjectByRoot(context, root);
+    const now = context.now();
+    const project = existing ?? newProjectRecord(context, root, now);
+    if (existing) {
+        context.db.run("UPDATE projects SET status = 'active', updated_at = ? WHERE id = ?", [now, existing.id]);
+    }
+    else {
+        context.db.run("INSERT INTO projects (id, short_id, slug, root, status, state_root, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", [
+            project.id,
+            project.short_id,
+            project.slug,
+            project.root,
+            project.status,
+            project.state_root,
+            project.created_at,
+            project.updated_at
+        ]);
+        appendAudit(context, {
+            projectId: project.id,
+            eventType: "project.registered",
+            payload: { project_id: project.id, root }
+        });
+    }
+    return { ok: true, project: { ...project, status: "active", updated_at: now }, db_path: context.db.path };
+}
+export function archiveProject(context, input) {
+    const reason = input.reason.trim();
+    if (!reason) {
+        throw new AppError("validation", "project archive requires --reason", 2);
+    }
+    const project = input.root
+        ? findProjectByRoot(context, normalizeStoredRoot(input.root))
+        : input.idOrAlias
+            ? resolveSingleProject(context, input.idOrAlias)
+            : undefined;
+    if (!project) {
+        throw new AppError("not_found", "Project is not registered.", 1, { root: input.root, input: input.idOrAlias });
+    }
+    const now = context.now();
+    const result = context.db.run("UPDATE projects SET status = 'archived', updated_at = ? WHERE id = ? AND status <> 'archived'", [now, project.id]);
+    if (result.changes === 1) {
+        appendAudit(context, {
+            projectId: project.id,
+            eventType: "project.archived",
+            reason,
+            payload: { project_id: project.id, root: project.root }
+        });
+    }
+    return {
+        ok: true,
+        changed: result.changes === 1,
+        project: context.db.get("SELECT * FROM projects WHERE id = ?", [project.id]),
+        ...(result.changes === 1 ? {} : { skipped: true, reason: "already_archived" })
+    };
+}
+function normalizeStoredRoot(root) {
+    const absolute = path.resolve(root);
+    if (fs.existsSync(absolute)) {
+        return fs.realpathSync(absolute);
+    }
+    const parent = path.dirname(absolute);
+    if (fs.existsSync(parent)) {
+        return path.join(fs.realpathSync(parent), path.basename(absolute));
+    }
+    return absolute;
+}
+export function resolveProject(context, input) {
+    const candidates = resolveProjectCandidates(context, input.idOrAlias);
+    if (candidates.length === 1) {
+        return { ok: true, project: candidates[0], input: input.idOrAlias };
+    }
+    if (candidates.length > 1) {
+        throw new AppError("ambiguous_alias", `Project alias is ambiguous: ${input.idOrAlias}`, 1, {
+            input: input.idOrAlias,
+            candidates: candidates.map(projectSummary)
+        });
+    }
+    const details = { input: input.idOrAlias };
+    if (!isFullEntityId(input.idOrAlias) && !isShortEntityId(input.idOrAlias)) {
+        details.expected = "Use full id PRJ-NNN-slug, short alias PRJ-NNN, or --root for root-based commands.";
+    }
+    throw new AppError("not_found", `Project is not registered: ${input.idOrAlias}`, 1, details);
+}
+export function migrateProjectIds(context, input) {
+    const root = resolveProjectRoot(input.root);
+    const existing = findProjectByRoot(context, root);
+    if (!existing) {
+        throw new AppError("not_found", `Project is not registered: ${root}`, 1);
+    }
+    const typed = typedProjectMetadata(existing);
+    if (typed && existing.state_root) {
+        return { ok: true, action: "noop", apply: input.apply, project: existing, message: "Project already uses typed ids." };
+    }
+    const now = context.now();
+    const target = typed ? backfilledTypedProjectRecord(context, existing, typed, now) : newProjectRecord(context, root, now);
+    const oldId = existing.id;
+    const plan = {
+        old_project_id: oldId,
+        new_project_id: target.id,
+        short_id: target.short_id,
+        slug: target.slug,
+        state_root: target.state_root,
+        tables: projectReferenceTables()
+    };
+    if (!input.apply) {
+        return { ok: true, action: "dry_run", apply: false, plan };
+    }
+    const conflictingProject = context.db.get("SELECT * FROM projects WHERE id = ? AND root <> ?", [target.id, root]);
+    if (conflictingProject) {
+        throw new AppError("conflict", `Target project id already exists: ${target.id}`, 1, plan);
+    }
+    context.db.exec("PRAGMA foreign_keys = OFF");
+    context.db.exec("BEGIN IMMEDIATE");
+    try {
+        context.db.run("UPDATE projects SET id = ?, short_id = ?, slug = ?, state_root = ?, updated_at = ? WHERE id = ?", [target.id, target.short_id, target.slug, target.state_root, now, oldId]);
+        for (const table of projectReferenceTables()) {
+            context.db.run(`UPDATE ${table} SET project_id = ? WHERE project_id = ?`, [target.id, oldId]);
+        }
+        const foreignKeyErrors = context.db.all("PRAGMA foreign_key_check");
+        if (foreignKeyErrors.length > 0) {
+            throw new AppError("integrity_error", "Project id migration would leave invalid foreign keys.", 1, {
+                plan,
+                foreign_key_errors: foreignKeyErrors
+            });
+        }
+        context.db.exec("COMMIT");
+        context.db.exec("PRAGMA foreign_keys = ON");
+    }
+    catch (error) {
+        context.db.exec("ROLLBACK");
+        context.db.exec("PRAGMA foreign_keys = ON");
+        throw error;
+    }
+    appendAudit(context, {
+        projectId: target.id,
+        eventType: "project.id_migrated",
+        payload: plan
+    });
+    return { ok: true, action: "applied", apply: true, plan, project: findProjectByRoot(context, root) };
+}
+export function getProjectStatus(context, input) {
+    const root = resolveProjectRoot(input.root);
+    const project = findProjectByRoot(context, root);
+    if (!project) {
+        throw new AppError("not_found", `Project is not registered: ${root}`, 1);
+    }
+    const protocols = context.db.all(`SELECT id, status, stage, next_action, updated_at
+     FROM protocols
+     WHERE project_id = ?
+     ORDER BY updated_at DESC`, [project.id]);
+    const mergeQueue = context.db.all(`SELECT protocol_id, status, claimed_by_session_id, claimed_at, attempts_count, last_reason, completed_at,
+       created_at, updated_at
+     FROM merge_queue
+     WHERE project_id = ?
+     ORDER BY created_at ASC`, [project.id]);
+    const config = readProjectConfig(context, project.id);
+    const worktrees = context.db.all(`SELECT protocol_id, feature_branch, worktree_path, bootstrap_status, status, updated_at
+     FROM worktree_records
+     WHERE project_id = ?
+     ORDER BY updated_at DESC`, [project.id]);
+    return {
+        ok: true,
+        project,
+        config,
+        dashboard: {
+            project_markdown_path: dashboardMarkdownPath(project.root, config),
+            global_markdown_path: globalDashboardMarkdownPath(context, config),
+            auto_refresh: config.dashboard.auto_refresh,
+            project_enabled: config.dashboard.project,
+            global_enabled: config.dashboard.global,
+            cmux_mode: config.integrations.cmux.mode
+        },
+        protocols,
+        merge_queue: mergeQueue,
+        hook_status: hookStatusForProject(context, project.id),
+        codex_home_profiles: codexHomeProfilesForProject(context, project.id),
+        flow_sessions: activeFlowSessionBindingsForProject(context, project.id),
+        codex_session_bindings: activeCodexSessionBindingsForProject(context, project.id),
+        codex_hook_events: codexHookEventsForProject(context, project.id),
+        worktrees,
+        lane_status: {
+            lanes: context.db.all("SELECT * FROM lanes WHERE project_id = ? ORDER BY name ASC", [project.id]),
+            locks: context.db.all(`SELECT * FROM lane_locks WHERE project_id = ? ORDER BY updated_at DESC, id DESC LIMIT 50`, [project.id])
+        }
+    };
+}
+export function findProjectByRoot(context, root) {
+    return context.db.get("SELECT * FROM projects WHERE root = ?", [root]);
+}
+export function requireProjectByRoot(context, root) {
+    const project = findProjectByRoot(context, root);
+    if (!project) {
+        throw new AppError("not_found", `Project is not registered: ${root}`, 1);
+    }
+    return project;
+}
+function newProjectRecord(context, root, now) {
+    const slug = slugFromRoot(root);
+    const id = nextFullProjectId(context, slug);
+    const { shortId } = parseFullEntityId(id);
+    return {
+        id,
+        short_id: shortId,
+        slug,
+        root,
+        status: "active",
+        state_root: projectRuntimeRoot(context.ddFlowHome, id),
+        created_at: now,
+        updated_at: now
+    };
+}
+function backfilledTypedProjectRecord(context, project, typed, now) {
+    return {
+        ...project,
+        short_id: typed.shortId,
+        slug: typed.slug,
+        state_root: projectRuntimeRoot(context.ddFlowHome, project.id),
+        updated_at: now
+    };
+}
+function nextFullProjectId(context, slug) {
+    const rows = context.db.all("SELECT id FROM projects WHERE id LIKE 'PRJ-%'");
+    const used = rows
+        .map((row) => /^PRJ-(\d{3})-/.exec(row.id)?.[1])
+        .filter((value) => Boolean(value))
+        .map((value) => Number(value));
+    const next = Math.max(0, ...used) + 1;
+    return formatFullId("PRJ", next, slug);
+}
+function typedProjectMetadata(project) {
+    if (!isFullEntityId(project.id)) {
+        return null;
+    }
+    const parsed = parseFullEntityId(project.id);
+    return { shortId: parsed.shortId, slug: parsed.slug };
+}
+function resolveProjectCandidates(context, idOrAlias) {
+    if (isShortEntityId(idOrAlias)) {
+        return context.db.all("SELECT * FROM projects WHERE short_id = ? ORDER BY id ASC", [idOrAlias]);
+    }
+    if (isFullEntityId(idOrAlias)) {
+        return context.db.all("SELECT * FROM projects WHERE id = ? ORDER BY id ASC", [idOrAlias]);
+    }
+    return [];
+}
+function resolveSingleProject(context, idOrAlias) {
+    return resolveProject(context, { idOrAlias }).project;
+}
+function projectSummary(project) {
+    return {
+        id: project.id,
+        short_id: project.short_id,
+        slug: project.slug,
+        root: project.root,
+        status: project.status,
+        state_root: project.state_root
+    };
+}
+function projectReferenceTables() {
+    return [
+        "protocols",
+        "audit_events",
+        "merge_queue",
+        "merge_sessions",
+        "lanes",
+        "lane_locks",
+        "hook_installations",
+        "codex_home_profiles",
+        "codex_session_bindings",
+        "project_config",
+        "flow_sessions",
+        "pending_flow_session_bindings",
+        "codex_hook_events",
+        "worktree_records"
+    ];
+}