ndomo 0.1.0

package/tools/analysis_create.ts

@@ -0,0 +1,55 @@
+/**
+ * ndomo — analysis_create custom tool.
+ *
+ * Create a new analysis record in the standalone analyses table.
+ * Use for analyst findings, architecture audits, onboarding notes,
+ * or cartography outputs. Optionally link to a source plan via sourcePlanId.
+ */
+
+import { tool } from "@opencode-ai/plugin";
+import type { InsertAnalysis } from "ndomo/db";
+import { closeDb, createAnalysis, openDb, resolveProjectDir, runMigrations } from "ndomo/db";
+
+export default tool({
+  description:
+    "Create a new analysis record in the standalone analyses table. Use for analyst findings, architecture audits, onboarding notes, or cartography outputs. Optionally link to a source plan via sourcePlanId.",
+  args: {
+    slug: tool.schema.string(),
+    title: tool.schema.string(),
+    projectPath: tool.schema.string(),
+    summary: tool.schema.string(),
+    findingsJson: tool.schema.string(),
+    sourcePlanId: tool.schema.string().optional(),
+    agent: tool.schema.string().optional(),
+    sessionId: tool.schema.string().optional(),
+  },
+  execute: async (args, ctx) => {
+    // Validate findingsJson is valid JSON
+    try {
+      JSON.parse(args.findingsJson);
+    } catch {
+      throw new Error("ndomo: findingsJson must be valid JSON");
+    }
+
+    const projectDir = resolveProjectDir(ctx);
+    const db = openDb(projectDir);
+    runMigrations(db);
+    try {
+      const input: InsertAnalysis = {
+        slug: args.slug,
+        title: args.title,
+        projectPath: args.projectPath,
+        summary: args.summary,
+        findingsJson: args.findingsJson,
+        agent: args.agent ?? "ranger",
+        createdBy: ctx.agent ?? "ranger",
+        ...(args.sourcePlanId !== undefined && { sourcePlanId: args.sourcePlanId }),
+        ...(args.sessionId !== undefined && { sessionId: args.sessionId }),
+      };
+      const result = createAnalysis(db, input);
+      return JSON.stringify(result, null, 2);
+    } finally {
+      closeDb(db);
+    }
+  },
+});

package/tools/analysis_get.ts

@@ -0,0 +1,33 @@
+/**
+ * ndomo — analysis_get custom tool.
+ *
+ * Get a single analysis by id. Returns the analysis with parsed findingsJson.
+ */
+
+import { tool } from "@opencode-ai/plugin";
+import { closeDb, getAnalysis, openDb, resolveProjectDir, runMigrations } from "ndomo/db";
+
+export default tool({
+  description: "Get a single analysis by id. Returns the analysis with parsed findingsJson.",
+  args: {
+    id: tool.schema.string(),
+  },
+  execute: async (args, ctx) => {
+    const projectDir = resolveProjectDir(ctx);
+    const db = openDb(projectDir);
+    runMigrations(db);
+    try {
+      const result = getAnalysis(db, args.id);
+      if (!result) {
+        throw new Error(`ndomo: analysis '${args.id}' not found`);
+      }
+      return JSON.stringify(
+        { ...result, findingsJson: JSON.parse(result.findingsJson) },
+        null,
+        2,
+      );
+    } finally {
+      closeDb(db);
+    }
+  },
+});

package/tools/analysis_link_plan.ts

@@ -0,0 +1,44 @@
+/**
+ * ndomo — analysis_link_plan custom tool.
+ *
+ * Link an existing analysis to a source plan (set source_plan_id).
+ * Pass null to unlink.
+ */
+
+import { tool } from "@opencode-ai/plugin";
+import {
+  closeDb,
+  linkAnalysisToPlan,
+  openDb,
+  resolveProjectDir,
+  runMigrations,
+  unlinkAnalysisFromPlan,
+} from "ndomo/db";
+
+export default tool({
+  description:
+    "Link an existing analysis to a source plan (set source_plan_id). Pass null to unlink.",
+  args: {
+    id: tool.schema.string(),
+    planId: tool.schema.string().nullable(),
+  },
+  execute: async (args, ctx) => {
+    const projectDir = resolveProjectDir(ctx);
+    const db = openDb(projectDir);
+    runMigrations(db);
+    try {
+      if (args.planId === null) {
+        const result = unlinkAnalysisFromPlan(db, args.id);
+        return JSON.stringify({ ok: true, id: result.id, sourcePlanId: null }, null, 2);
+      }
+      const result = linkAnalysisToPlan(db, args.id, args.planId);
+      return JSON.stringify(
+        { ok: true, id: result.id, sourcePlanId: result.sourcePlanId },
+        null,
+        2,
+      );
+    } finally {
+      closeDb(db);
+    }
+  },
+});

package/tools/analysis_list.ts

@@ -0,0 +1,48 @@
+/**
+ * ndomo — analysis_list custom tool.
+ *
+ * List analyses with optional filters: sourcePlanId, agent, projectPath, archived, limit.
+ */
+
+import { tool } from "@opencode-ai/plugin";
+import { closeDb, listAnalyses, openDb, resolveProjectDir, runMigrations } from "ndomo/db";
+
+export default tool({
+  description:
+    "List analyses with optional filters: sourcePlanId, agent, projectPath, archived, limit.",
+  args: {
+    sourcePlanId: tool.schema.string().optional(),
+    agent: tool.schema.string().optional(),
+    projectPath: tool.schema.string().optional(),
+    archived: tool.schema.boolean().optional(),
+    limit: tool.schema.number().optional(),
+  },
+  execute: async (args, ctx) => {
+    const projectDir = resolveProjectDir(ctx);
+    const db = openDb(projectDir);
+    runMigrations(db);
+    try {
+      const opts: {
+        sourcePlanId?: string;
+        agent?: string;
+        projectPath?: string;
+        archived?: boolean;
+        limit?: number;
+      } = {};
+      if (args.sourcePlanId !== undefined) opts.sourcePlanId = args.sourcePlanId;
+      if (args.agent !== undefined) opts.agent = args.agent;
+      if (args.projectPath !== undefined) opts.projectPath = args.projectPath;
+      if (args.archived !== undefined) opts.archived = args.archived;
+      if (args.limit !== undefined) opts.limit = args.limit;
+
+      const results = listAnalyses(db, opts);
+      return JSON.stringify(
+        results.map((r) => ({ ...r, findingsJson: JSON.parse(r.findingsJson) })),
+        null,
+        2,
+      );
+    } finally {
+      closeDb(db);
+    }
+  },
+});

package/tools/analysis_search.ts

@@ -0,0 +1,36 @@
+/**
+ * ndomo — analysis_search custom tool.
+ *
+ * Full-text search over analyses (title + summary + findings) using FTS5.
+ * Returns matching analyses.
+ */
+
+import { tool } from "@opencode-ai/plugin";
+import { closeDb, openDb, resolveProjectDir, runMigrations, searchAnalyses } from "ndomo/db";
+
+export default tool({
+  description:
+    "Full-text search over analyses (title + summary + findings) using FTS5. Returns matching analyses.",
+  args: {
+    query: tool.schema.string(),
+    limit: tool.schema.number().optional(),
+  },
+  execute: async (args, ctx) => {
+    const projectDir = resolveProjectDir(ctx);
+    const db = openDb(projectDir);
+    runMigrations(db);
+    try {
+      const opts: { limit?: number } = {};
+      if (args.limit !== undefined) opts.limit = args.limit;
+
+      const results = searchAnalyses(db, args.query, opts);
+      return JSON.stringify(
+        results.map((r) => ({ ...r, findingsJson: JSON.parse(r.findingsJson) })),
+        null,
+        2,
+      );
+    } finally {
+      closeDb(db);
+    }
+  },
+});

package/tools/analysis_update.ts

@@ -0,0 +1,44 @@
+/**
+ * ndomo — analysis_update custom tool.
+ *
+ * Update an existing analysis. Only provided fields are changed. Bumps updated_at.
+ */
+
+import { tool } from "@opencode-ai/plugin";
+import type { InsertAnalysis } from "ndomo/db";
+import { closeDb, openDb, resolveProjectDir, runMigrations, updateAnalysis } from "ndomo/db";
+
+export default tool({
+  description: "Update an existing analysis. Only provided fields are changed. Bumps updated_at.",
+  args: {
+    id: tool.schema.string(),
+    title: tool.schema.string().optional(),
+    summary: tool.schema.string().optional(),
+    findingsJson: tool.schema.string().optional(),
+  },
+  execute: async (args, ctx) => {
+    // Validate findingsJson if provided
+    if (args.findingsJson !== undefined) {
+      try {
+        JSON.parse(args.findingsJson);
+      } catch {
+        throw new Error("ndomo: findingsJson must be valid JSON");
+      }
+    }
+
+    const projectDir = resolveProjectDir(ctx);
+    const db = openDb(projectDir);
+    runMigrations(db);
+    try {
+      const patch: Partial<InsertAnalysis> = {};
+      if (args.title !== undefined) patch.title = args.title;
+      if (args.summary !== undefined) patch.summary = args.summary;
+      if (args.findingsJson !== undefined) patch.findingsJson = args.findingsJson;
+
+      const result = updateAnalysis(db, args.id, patch);
+      return JSON.stringify(result, null, 2);
+    } finally {
+      closeDb(db);
+    }
+  },
+});

package/tools/plan_approve.ts

@@ -0,0 +1,31 @@
+/**
+ * ndomo — plan_approve custom tool.
+ *
+ * Mirror of the equivalent plugin tool in src/plugin.ts, exposed as a
+ * standalone OpenCode custom tool. Opens its own DB connection and runs
+ * migrations on first use. Use this when you want DB access from outside
+ * the plugin (e.g. from agents that don't load the plugin).
+ */
+
+import { tool } from "@opencode-ai/plugin";
+import { approvePlan, closeDb, openDb, resolveProjectDir, runMigrations } from "ndomo/db";
+
+export default tool({
+  description: "Mark a plan as approved. Sets approved_at to the current timestamp.",
+  args: { id: tool.schema.string() },
+  execute: async (args, ctx) => {
+    const projectDir = resolveProjectDir(ctx);
+    const db = openDb(projectDir);
+    runMigrations(db);
+    try {
+      return JSON.stringify(
+        approvePlan(db, args.id, {
+          sessionId: ctx.sessionID,
+          updatedBy: ctx.agent ?? "unknown",
+        }),
+      );
+    } finally {
+      closeDb(db);
+    }
+  },
+});

package/tools/plan_create.ts

@@ -0,0 +1,58 @@
+/**
+ * ndomo — plan_create custom tool.
+ *
+ * Mirror of the equivalent plugin tool in src/plugin.ts, exposed as a
+ * standalone OpenCode custom tool. Opens its own DB connection and runs
+ * migrations on first use. Use this when you want DB access from outside
+ * the plugin (e.g. from agents that don't load the plugin).
+ */
+
+import crypto from "node:crypto";
+import { tool } from "@opencode-ai/plugin";
+import type { PlanMetadata } from "ndomo/db";
+import { closeDb, createPlan, openDb, resolveProjectDir, runMigrations } from "ndomo/db";
+
+export default tool({
+  description: "Create a new plan in the ndomo state database.",
+  args: {
+    slug: tool.schema.string(),
+    title: tool.schema.string(),
+    overview: tool.schema.string(),
+    approach: tool.schema.string().optional(),
+    priority: tool.schema.number().optional(),
+    complexity: tool.schema.number().int().min(1).max(5).optional(),
+    sessionId: tool.schema.string().optional(),
+    metadata: tool.schema.record(tool.schema.string(), tool.schema.unknown()).optional(),
+  },
+  execute: async (args, ctx) => {
+    const projectDir = resolveProjectDir(ctx);
+    const db = openDb(projectDir);
+    runMigrations(db);
+    try {
+      const typedMeta = (args.metadata ?? {}) as PlanMetadata;
+      const plan = createPlan(db, {
+        id: crypto.randomUUID(),
+        slug: args.slug,
+        title: args.title,
+        status: "draft" as const,
+        priority: args.priority ?? 0,
+        approvedAt: null,
+        completedAt: null,
+        sessionId: args.sessionId ?? null,
+        overview: args.overview,
+        approach: args.approach ?? null,
+        complexity: args.complexity ?? 3,
+        createdBy: ctx.agent ?? "unknown",
+        updatedBy: ctx.agent ?? "unknown",
+        sourceSessionId: ctx.sessionID,
+        sourceMessageId: ctx.messageID,
+        category: typedMeta.category ?? null,
+        metadata: typedMeta,
+        archivedAt: null,
+      });
+      return JSON.stringify(plan);
+    } finally {
+      closeDb(db);
+    }
+  },
+});

package/tools/plan_get.ts

@@ -0,0 +1,40 @@
+/**
+ * ndomo — plan_get custom tool.
+ *
+ * Mirror of the equivalent plugin tool in src/plugin.ts, exposed as a
+ * standalone OpenCode custom tool. Opens its own DB connection and runs
+ * migrations on first use. Use this when you want DB access from outside
+ * the plugin (e.g. from agents that don't load the plugin).
+ */
+
+import { tool } from "@opencode-ai/plugin";
+import {
+  closeDb,
+  getPlan,
+  getPlanBySlug,
+  openDb,
+  resolveProjectDir,
+  runMigrations,
+} from "ndomo/db";
+
+export default tool({
+  description: "Get a plan by ID or slug.",
+  args: {
+    id: tool.schema.string().optional(),
+    slug: tool.schema.string().optional(),
+  },
+  execute: async (args, ctx) => {
+    if (!args.id && !args.slug) {
+      throw new Error("ndomo: plan_get requires id or slug");
+    }
+    const projectDir = resolveProjectDir(ctx);
+    const db = openDb(projectDir);
+    runMigrations(db);
+    try {
+      const plan = args.id ? getPlan(db, args.id) : getPlanBySlug(db, args.slug as string);
+      return JSON.stringify(plan);
+    } finally {
+      closeDb(db);
+    }
+  },
+});

package/tools/plan_list.ts

@@ -0,0 +1,37 @@
+/**
+ * ndomo — plan_list custom tool.
+ *
+ * Mirror of the equivalent plugin tool in src/plugin.ts, exposed as a
+ * standalone OpenCode custom tool. Opens its own DB connection and runs
+ * migrations on first use. Use this when you want DB access from outside
+ * the plugin (e.g. from agents that don't load the plugin).
+ */
+
+import { tool } from "@opencode-ai/plugin";
+import type { PlanStatus } from "ndomo/db";
+import { closeDb, listPlans, openDb, resolveProjectDir, runMigrations } from "ndomo/db";
+
+export default tool({
+  description: "List plans, optionally filtered by status and session.",
+  args: {
+    status: tool.schema
+      .enum(["draft", "approved", "executing", "completed", "failed", "abandoned"])
+      .optional(),
+    sessionId: tool.schema.string().optional(),
+    limit: tool.schema.number().optional(),
+  },
+  execute: async (args, ctx) => {
+    const projectDir = resolveProjectDir(ctx);
+    const db = openDb(projectDir);
+    runMigrations(db);
+    try {
+      const opts: { status?: PlanStatus; sessionId?: string; limit?: number } = {};
+      if (args.status) opts.status = args.status;
+      if (args.sessionId) opts.sessionId = args.sessionId;
+      if (args.limit !== undefined) opts.limit = args.limit;
+      return JSON.stringify(listPlans(db, opts));
+    } finally {
+      closeDb(db);
+    }
+  },
+});

package/tools/plan_search.ts

@@ -0,0 +1,34 @@
+/**
+ * ndomo — plan_search custom tool.
+ *
+ * Mirror of the equivalent plugin tool in src/plugin.ts, exposed as a
+ * standalone OpenCode custom tool. Opens its own DB connection and runs
+ * migrations on first use. Use this when you want DB access from outside
+ * the plugin (e.g. from agents that don't load the plugin).
+ */
+
+import { tool } from "@opencode-ai/plugin";
+import { closeDb, openDb, resolveProjectDir, runMigrations, searchPlans } from "ndomo/db";
+
+export default tool({
+  description: "Full-text search over plan titles, overviews, and approaches using SQLite FTS5.",
+  args: {
+    query: tool.schema.string(),
+    limit: tool.schema.number().optional(),
+    includeArchived: tool.schema.boolean().optional(),
+  },
+  execute: async (args, ctx) => {
+    const projectDir = resolveProjectDir(ctx);
+    const db = openDb(projectDir);
+    runMigrations(db);
+    try {
+      return JSON.stringify(
+        searchPlans(db, args.query, args.limit ?? 20, {
+          includeArchived: args.includeArchived ?? false,
+        }),
+      );
+    } finally {
+      closeDb(db);
+    }
+  },
+});

package/tools/plan_update_status.ts

@@ -0,0 +1,71 @@
+/**
+ * ndomo — plan_update_status custom tool.
+ *
+ * Mirror of the equivalent plugin tool in src/plugin.ts, exposed as a
+ * standalone OpenCode custom tool. Opens its own DB connection and runs
+ * migrations on first use. Use this when you want DB access from outside
+ * the plugin (e.g. from agents that don't load the plugin).
+ *
+ * Special: also auto-archives to markdown on terminal statuses.
+ */
+
+import { tool } from "@opencode-ai/plugin";
+import type { ArchiveResult, PlanStatus } from "ndomo/db";
+import {
+  archivePlan,
+  closeDb,
+  openDb,
+  resolveArchiveDir,
+  resolveProjectDir,
+  runMigrations,
+  updatePlanStatus,
+} from "ndomo/db";
+
+export default tool({
+  description:
+    "Update a plan's status (draft, approved, executing, completed, failed, abandoned). Auto-archives to markdown on terminal status.",
+  args: {
+    id: tool.schema.string(),
+    status: tool.schema.enum([
+      "draft",
+      "approved",
+      "executing",
+      "completed",
+      "failed",
+      "abandoned",
+    ]),
+  },
+  execute: async (args, ctx) => {
+    const projectDir = resolveProjectDir(ctx);
+    const db = openDb(projectDir);
+    runMigrations(db);
+    try {
+      const updated = updatePlanStatus(db, args.id, args.status as PlanStatus, {
+        sessionId: ctx.sessionID,
+        updatedBy: ctx.agent ?? "unknown",
+      });
+
+      // Auto-archive on terminal status
+      const TERMINAL_STATUSES = new Set(["completed", "failed", "abandoned"]);
+      let archiveResult: ArchiveResult | null = null;
+      let archiveError: string | null = null;
+
+      if (updated && TERMINAL_STATUSES.has(args.status)) {
+        try {
+          archiveResult = archivePlan(db, updated.id, { memDir: resolveArchiveDir(projectDir) });
+        } catch (err) {
+          archiveError = err instanceof Error ? err.message : String(err);
+          console.warn(`[ndomo] auto-archive failed for plan ${updated.id}: ${archiveError}`);
+        }
+      }
+
+      return JSON.stringify({
+        plan: updated,
+        archived: archiveResult,
+        archiveError,
+      });
+    } finally {
+      closeDb(db);
+    }
+  },
+});

package/tools/session_checkpoint.ts

@@ -0,0 +1,31 @@
+/**
+ * ndomo — session_checkpoint custom tool.
+ *
+ * Mirror of the equivalent plugin tool in src/plugin.ts, exposed as a
+ * standalone OpenCode custom tool. Opens its own DB connection and runs
+ * migrations on first use. Use this when you want DB access from outside
+ * the plugin (e.g. from agents that don't load the plugin).
+ */
+
+import { tool } from "@opencode-ai/plugin";
+import { checkpointSession, closeDb, openDb, resolveProjectDir, runMigrations } from "ndomo/db";
+
+export default tool({
+  description:
+    "Save a checkpoint in an active session with arbitrary state and optional key decisions.",
+  args: {
+    id: tool.schema.string(),
+    state: tool.schema.record(tool.schema.string(), tool.schema.unknown()),
+    keyDecisions: tool.schema.string().optional(),
+  },
+  execute: async (args, ctx) => {
+    const projectDir = resolveProjectDir(ctx);
+    const db = openDb(projectDir);
+    runMigrations(db);
+    try {
+      return JSON.stringify(checkpointSession(db, args.id, args.state, args.keyDecisions));
+    } finally {
+      closeDb(db);
+    }
+  },
+});

package/tools/session_end.ts

@@ -0,0 +1,26 @@
+/**
+ * ndomo — session_end custom tool.
+ *
+ * Mirror of the equivalent plugin tool in src/plugin.ts, exposed as a
+ * standalone OpenCode custom tool. Opens its own DB connection and runs
+ * migrations on first use. Use this when you want DB access from outside
+ * the plugin (e.g. from agents that don't load the plugin).
+ */
+
+import { tool } from "@opencode-ai/plugin";
+import { closeDb, endSession, openDb, resolveProjectDir, runMigrations } from "ndomo/db";
+
+export default tool({
+  description: "Mark a session as ended. Sets ended_at to the current timestamp.",
+  args: { id: tool.schema.string() },
+  execute: async (args, ctx) => {
+    const projectDir = resolveProjectDir(ctx);
+    const db = openDb(projectDir);
+    runMigrations(db);
+    try {
+      return JSON.stringify(endSession(db, args.id));
+    } finally {
+      closeDb(db);
+    }
+  },
+});

package/tools/session_start.ts

@@ -0,0 +1,43 @@
+/**
+ * ndomo — session_start custom tool.
+ *
+ * Mirror of the equivalent plugin tool in src/plugin.ts, exposed as a
+ * standalone OpenCode custom tool. Opens its own DB connection and runs
+ * migrations on first use. Use this when you want DB access from outside
+ * the plugin (e.g. from agents that don't load the plugin).
+ */
+
+import { tool } from "@opencode-ai/plugin";
+import type { SessionMetadata } from "ndomo/db";
+import { closeDb, openDb, resolveProjectDir, runMigrations, startSession } from "ndomo/db";
+
+export default tool({
+  description:
+    "Start a new ndomo session with a goal. Sessions track continuity across multiple agents.",
+  args: {
+    id: tool.schema.string(),
+    goal: tool.schema.string(),
+    planId: tool.schema.string().optional(),
+    metadata: tool.schema.record(tool.schema.string(), tool.schema.unknown()).optional(),
+  },
+  execute: async (args, ctx) => {
+    const projectDir = resolveProjectDir(ctx);
+    const db = openDb(projectDir);
+    runMigrations(db);
+    try {
+      const typedMeta = (args.metadata ?? {}) as SessionMetadata;
+      return JSON.stringify(
+        startSession(db, {
+          id: args.id,
+          goal: args.goal,
+          ...(args.planId !== undefined && { planId: args.planId }),
+          metadata: typedMeta,
+          createdBy: ctx.agent ?? "unknown",
+          sourceMessageId: ctx.messageID,
+        }),
+      );
+    } finally {
+      closeDb(db);
+    }
+  },
+});