@whatasoda/agent-tools 0.1.0

package/dist/src/cli/commands/import.js

@@ -0,0 +1,174 @@
+import path from "path";
+import { Glob } from "bun";
+import { exitWithError, outputJson } from "../helpers.js";
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match)
+    return { topic: "", status: "", date: "" };
+  const fm = match[1];
+  const topic = fm.match(/^topic:\s*(.+)$/m)?.[1]?.trim() ?? "";
+  const status = fm.match(/^status:\s*(.+)$/m)?.[1]?.trim() ?? "";
+  const date = fm.match(/^date:\s*(.+)$/m)?.[1]?.trim() ?? "";
+  return { topic, status, date };
+}
+function parseLDD(content, filePath) {
+  const fm = parseFrontmatter(content);
+  const decisions = [];
+  const topicSections = content.split(/^## Topic \d+:/m).slice(1);
+  for (const section of topicSections) {
+    const sectionDDs = [];
+    const sectionRAs = [];
+    const ddBlocks = section.split(/^#### DD-\d+:\s*/m).slice(1);
+    for (const block of ddBlocks) {
+      const name = block.split(`
+`)[0].trim();
+      const constraint = block.match(/\*\*Constraint\*\*:\s*([\s\S]*?)(?=\n- \*\*)/)?.[1]?.trim() ?? "";
+      const why = block.match(/\*\*Why\*\*:\s*([\s\S]*?)(?=\n- \*\*|\n\n|$)/)?.[1]?.trim() ?? "";
+      const scope = block.match(/\*\*Scope\*\*:\s*([\s\S]*?)(?=\n\n|$)/)?.[1]?.trim() ?? "";
+      if (constraint || name) {
+        sectionDDs.push({ name, constraint, why, scope, rejectedAlternatives: [] });
+      }
+    }
+    const raBlocks = section.split(/^#### RA-\d+:\s*/m).slice(1);
+    for (const block of raBlocks) {
+      const what = block.match(/\*\*What\*\*:\s*([\s\S]*?)(?=\n- \*\*)/)?.[1]?.trim() ?? block.split(`
+`)[0].trim();
+      const whyRejected = block.match(/\*\*Why rejected\*\*:\s*([\s\S]*?)(?=\n\n|$)/)?.[1]?.trim() ?? "";
+      if (what) {
+        sectionRAs.push({ what, why_rejected: whyRejected });
+      }
+    }
+    if (sectionRAs.length > 0 && sectionDDs.length > 0) {
+      sectionDDs[sectionDDs.length - 1].rejectedAlternatives = sectionRAs;
+    }
+    decisions.push(...sectionDDs);
+  }
+  return { ...fm, decisions, filePath };
+}
+async function detectRepo() {
+  try {
+    const proc = Bun.spawn(["git", "remote", "get-url", "origin"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const url = (await new Response(proc.stdout).text()).trim();
+    await proc.exited;
+    if (proc.exitCode !== 0)
+      return null;
+    const sshMatch = url.match(/[:/]([^/]+)\/([^/]+?)(?:\.git)?$/);
+    if (sshMatch)
+      return { owner: sshMatch[1], name: sshMatch[2] };
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function scanForLDDs() {
+  const repoRoot = await getRepoRoot();
+  if (!repoRoot) {
+    return exitWithError("Not in a git repository");
+  }
+  const patterns = [
+    ".agent-discussions/*.md",
+    ".worktrees/*/.agent-discussions/*.md",
+    ".claude/worktrees/*/.agent-discussions/*.md"
+  ];
+  const found = new Map;
+  for (const pattern of patterns) {
+    const glob = new Glob(pattern);
+    for await (const file of glob.scan({ cwd: repoRoot, absolute: true, dot: true })) {
+      const basename = path.basename(file);
+      if (!found.has(basename)) {
+        found.set(basename, file);
+      }
+    }
+  }
+  return [...found.values()].sort();
+}
+async function getRepoRoot() {
+  try {
+    const proc = Bun.spawn(["git", "rev-parse", "--show-toplevel"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const root = (await new Response(proc.stdout).text()).trim();
+    await proc.exited;
+    return root || null;
+  } catch {
+    return null;
+  }
+}
+export async function handleImport(db, args) {
+  const scanMode = args.includes("--scan");
+  const dryRun = args.includes("--dry-run");
+  const fileArgs = args.filter((a) => !a.startsWith("--"));
+  let files;
+  if (scanMode) {
+    files = await scanForLDDs();
+    if (files.length === 0) {
+      console.log("No .agent-discussions files found.");
+      return;
+    }
+    console.log(`Found ${files.length} LDD file(s):`);
+    for (const f of files)
+      console.log(`  ${f}`);
+    console.log("");
+  } else if (fileArgs.length > 0) {
+    files = fileArgs.map((f) => path.resolve(f));
+  } else {
+    return exitWithError(`Usage: sd decision import --scan  OR  sd decision import <file...>
+  --dry-run  Preview without writing to DB`);
+  }
+  const repo = await detectRepo();
+  const topicTag = (filePath) => {
+    const slug = path.basename(filePath, ".md").replace(/^\d{4}-\d{2}-\d{2}-/, "");
+    return `topic:${slug}`;
+  };
+  let totalImported = 0;
+  const results = [];
+  for (const file of files) {
+    const content = await Bun.file(file).text();
+    const ldd = parseLDD(content, file);
+    if (ldd.decisions.length === 0) {
+      results.push({ file, imported: 0, decisions: [] });
+      continue;
+    }
+    const tag = topicTag(file);
+    const importedNames = [];
+    for (const dd of ldd.decisions) {
+      if (dryRun) {
+        console.log(`[dry-run] Would create: "${dd.name}" (${tag})`);
+        if (dd.rejectedAlternatives.length > 0) {
+          console.log(`  with ${dd.rejectedAlternatives.length} rejected alternative(s)`);
+        }
+        importedNames.push(dd.name);
+        continue;
+      }
+      const properties = {
+        constraint: dd.constraint || dd.name,
+        why: dd.why,
+        scope: dd.scope,
+        rejected_alternatives: dd.rejectedAlternatives
+      };
+      if (repo) {
+        properties.repo_owner = repo.owner;
+        properties.repo_name = repo.name;
+      }
+      db.createNode({
+        kind: "decision",
+        body: dd.name,
+        properties,
+        tags: [tag]
+      });
+      importedNames.push(dd.name);
+      totalImported++;
+    }
+    results.push({ file, imported: importedNames.length, decisions: importedNames });
+  }
+  if (dryRun) {
+    console.log(`
+[dry-run] Would import ${results.reduce((s, r) => s + r.imported, 0)} decision(s) total`);
+  } else {
+    outputJson({ imported: totalImported, files: results });
+  }
+}

package/dist/src/cli/commands/link.js

@@ -0,0 +1,52 @@
+import { exitWithError, outputJson, parseCli } from "../helpers.js";
+export async function handleLink(db, args) {
+  const [action] = args;
+  const rest = args.slice(1);
+  switch (action) {
+    case "create":
+      return linkCreate(db, rest);
+    case "delete":
+      return linkDelete(db, rest);
+    case "list":
+      return linkList(db, rest);
+    default:
+      exitWithError("Usage: sd link <create|delete|list>");
+  }
+}
+async function linkCreate(db, args) {
+  const { positionals, values } = parseCli(args, {
+    type: { type: "string" }
+  });
+  const [fromId, toId] = positionals;
+  if (!fromId || !toId || !values.type) {
+    exitWithError("Usage: sd link create <from-id> <to-id> --type <link-type>");
+  }
+  const result = db.createLink(fromId, toId, values.type);
+  outputJson(result);
+}
+async function linkDelete(db, args) {
+  const { positionals, values } = parseCli(args, {
+    type: { type: "string" }
+  });
+  const [fromId, toId] = positionals;
+  if (!fromId || !toId || !values.type) {
+    exitWithError("Usage: sd link delete <from-id> <to-id> --type <link-type>");
+  }
+  db.deleteLink(fromId, toId, values.type);
+  outputJson({ success: true });
+}
+async function linkList(db, args) {
+  const { positionals, values } = parseCli(args, {
+    direction: { type: "string" }
+  });
+  const [nodeId] = positionals;
+  if (!nodeId) {
+    exitWithError("Usage: sd link list <node-id> [--direction from|to|both]");
+  }
+  const direction = values.direction ?? "both";
+  if (direction !== "from" && direction !== "to" && direction !== "both") {
+    exitWithError("Error: --direction must be from, to, or both");
+  }
+  const result = db.getLinks(nodeId, direction);
+  outputJson(result);
+}

package/dist/src/cli/commands/list.js

@@ -0,0 +1,12 @@
+import { exitWithError, outputJson } from "../helpers.js";
+export async function handleList(db, args) {
+  const [action] = args;
+  switch (action) {
+    case "kinds":
+      return outputJson(db.listKinds());
+    case "tags":
+      return outputJson(db.listTags());
+    default:
+      exitWithError("Usage: sd list <kinds|tags>");
+  }
+}

package/dist/src/cli/commands/node.js

@@ -0,0 +1,118 @@
+import { exitWithError, outputJson, parseCli, parseProps, readStdin } from "../helpers.js";
+export async function handleNode(db, args) {
+  const [action] = args;
+  const rest = args.slice(1);
+  switch (action) {
+    case "create":
+      return nodeCreate(db, rest);
+    case "get":
+      return nodeGet(db, rest);
+    case "update":
+      return nodeUpdate(db, rest);
+    case "delete":
+      return nodeDelete(db, rest);
+    case "search":
+      return nodeSearch(db, rest);
+    default:
+      exitWithError("Usage: sd node <create|get|update|delete|search>");
+  }
+}
+async function nodeCreate(db, args) {
+  const { values } = parseCli(args, {
+    body: { type: "string" },
+    kind: { type: "string" },
+    prop: { multiple: true, type: "string" },
+    "props-json": { type: "string" },
+    stdin: { default: false, type: "boolean" },
+    tags: { type: "string" }
+  });
+  if (values.stdin) {
+    const input = await readStdin();
+    const result = db.createNode({
+      body: input.body,
+      kind: input.kind,
+      properties: input.properties,
+      tags: input.tags
+    });
+    return outputJson(result);
+  }
+  if (!values.kind) {
+    exitWithError("Error: --kind is required");
+  }
+  const properties = parseProps(values.prop, values["props-json"]);
+  const tags = values.tags?.split(",");
+  const result = db.createNode({
+    body: values.body,
+    kind: values.kind,
+    properties,
+    tags
+  });
+  outputJson(result);
+}
+async function nodeGet(db, args) {
+  const { positionals } = parseCli(args, {});
+  const [id] = positionals;
+  if (!id) {
+    exitWithError("Usage: sd node get <id>");
+  }
+  const result = db.getNode(id);
+  outputJson(result);
+}
+async function nodeUpdate(db, args) {
+  const { positionals, values } = parseCli(args, {
+    body: { type: "string" },
+    kind: { type: "string" },
+    prop: { multiple: true, type: "string" },
+    "props-json": { type: "string" },
+    stdin: { default: false, type: "boolean" }
+  });
+  const [id] = positionals;
+  if (!id) {
+    exitWithError("Usage: sd node update <id> [--body ...] [--kind ...] [--prop ...] [--stdin]");
+  }
+  if (values.stdin) {
+    const input = await readStdin();
+    const result = db.updateNode({
+      body: input.body,
+      id,
+      kind: input.kind,
+      properties: input.properties
+    });
+    return outputJson(result);
+  }
+  const properties = parseProps(values.prop, values["props-json"]);
+  const result = db.updateNode({
+    body: values.body,
+    id,
+    kind: values.kind,
+    properties
+  });
+  outputJson(result);
+}
+async function nodeDelete(db, args) {
+  const { positionals } = parseCli(args, {});
+  const [id] = positionals;
+  if (!id) {
+    exitWithError("Usage: sd node delete <id>");
+  }
+  db.deleteNode(id);
+  outputJson({ success: true });
+}
+async function nodeSearch(db, args) {
+  const { values } = parseCli(args, {
+    kind: { type: "string" },
+    limit: { type: "string" },
+    offset: { type: "string" },
+    query: { type: "string" },
+    tags: { type: "string" }
+  });
+  const tags = values.tags?.split(",");
+  const result = db.search({
+    kind: values.kind,
+    limit: values.limit ? parseInt(values.limit, 10) : 20,
+    offset: values.offset ? parseInt(values.offset, 10) : 0,
+    query: values.query,
+    tags
+  });
+  outputJson(result);
+}

package/dist/src/cli/commands/review.js

@@ -0,0 +1,23 @@
+import path from "path";
+import { exitWithError } from "../helpers.js";
+const packageRoot = path.resolve(import.meta.dir, "../../../");
+export async function handleReview(args) {
+  const [action, ...rest] = args;
+  switch (action) {
+    case "detect-base-branch":
+      return reviewDetectBaseBranch(rest);
+    default:
+      exitWithError("Usage: soda review <detect-base-branch>");
+  }
+}
+async function reviewDetectBaseBranch(args) {
+  const scriptPath = path.join(packageRoot, "scripts", "detect-base-branch.ts");
+  const proc = Bun.spawn(["bun", scriptPath, ...args], {
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    process.exit(exitCode);
+  }
+}

package/dist/src/cli/commands/session.js

@@ -0,0 +1,23 @@
+import path from "path";
+import { exitWithError } from "../helpers.js";
+const packageRoot = path.resolve(import.meta.dir, "../../../");
+export async function handleSession(args) {
+  const [action, ...rest] = args;
+  switch (action) {
+    case "resolve":
+      return sessionResolve(rest);
+    default:
+      exitWithError("Usage: sd session <resolve>");
+  }
+}
+async function sessionResolve(args) {
+  const scriptPath = path.join(packageRoot, "scripts", "resolve-session.ts");
+  const proc = Bun.spawn(["bun", scriptPath, ...args], {
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    process.exit(exitCode);
+  }
+}

package/dist/src/cli/commands/skill.js

@@ -0,0 +1,29 @@
+import path from "path";
+import { exitWithError } from "../helpers.js";
+const packageRoot = path.resolve(import.meta.dir, "../../../");
+export async function handleSkill(args) {
+  const [action, name] = args;
+  switch (action) {
+    case "print":
+      return skillPrint(name);
+    default:
+      exitWithError("Usage: soda skill <print> <name>");
+  }
+}
+async function skillPrint(name) {
+  if (!name) {
+    exitWithError("Usage: soda skill print <name>");
+  }
+  const baseDir = path.join(packageRoot, "skills");
+  const filePath = path.resolve(baseDir, name, "body.md");
+  if (!filePath.startsWith(baseDir + path.sep)) {
+    exitWithError(`Invalid skill name: ${name}`);
+  }
+  const file = Bun.file(filePath);
+  const exists = await file.exists();
+  if (!exists) {
+    exitWithError(`Skill not found: ${name}`);
+  }
+  const content = await file.text();
+  process.stdout.write(content);
+}

package/dist/src/cli/commands/tag.js

@@ -0,0 +1,31 @@
+import { exitWithError, outputJson, parseCli } from "../helpers.js";
+export async function handleTag(db, args) {
+  const [action] = args;
+  const rest = args.slice(1);
+  switch (action) {
+    case "add":
+      return tagAdd(db, rest);
+    case "remove":
+      return tagRemove(db, rest);
+    default:
+      exitWithError("Usage: sd tag <add|remove> <node-id> <tag1> [tag2 ...]");
+  }
+}
+async function tagAdd(db, args) {
+  const { positionals } = parseCli(args, {});
+  const [nodeId, ...tags] = positionals;
+  if (!nodeId || tags.length === 0) {
+    exitWithError("Usage: sd tag add <node-id> <tag1> [tag2 ...]");
+  }
+  db.addTags(nodeId, tags);
+  outputJson({ success: true });
+}
+async function tagRemove(db, args) {
+  const { positionals } = parseCli(args, {});
+  const [nodeId, ...tags] = positionals;
+  if (!nodeId || tags.length === 0) {
+    exitWithError("Usage: sd tag remove <node-id> <tag1> [tag2 ...]");
+  }
+  db.removeTags(nodeId, tags);
+  outputJson({ success: true });
+}

package/dist/src/cli/helpers.js

@@ -0,0 +1,51 @@
+import { parseArgs } from "node:util";
+export function outputJson(data) {
+  console.log(JSON.stringify(data));
+}
+export function exitWithError(message) {
+  console.error(message);
+  process.exit(1);
+}
+export async function readStdin() {
+  const text = await Bun.stdin.text();
+  const trimmed = text.trim();
+  if (!trimmed) {
+    exitWithError("Error: --stdin specified but no input received");
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    exitWithError("Error: invalid JSON on stdin");
+  }
+}
+export function parseProps(propArgs, propsJson) {
+  if (!propArgs?.length && !propsJson) {
+    return;
+  }
+  let base = {};
+  if (propsJson) {
+    try {
+      base = JSON.parse(propsJson);
+    } catch {
+      exitWithError("Error: invalid JSON in --props-json");
+    }
+  }
+  if (propArgs?.length) {
+    for (const prop of propArgs) {
+      const eq = prop.indexOf("=");
+      if (eq === -1) {
+        exitWithError(`Error: invalid --prop format "${prop}", expected key=value`);
+      }
+      base[prop.slice(0, eq)] = prop.slice(eq + 1);
+    }
+  }
+  return base;
+}
+export function parseCli(args, options) {
+  return parseArgs({
+    allowPositionals: true,
+    args,
+    options,
+    strict: false
+  });
+}

package/dist/src/cli/index.js

@@ -0,0 +1,48 @@
+import os from "os";
+import path from "path";
+import { Database } from "../core/database.js";
+import { ensureDbDir } from "../core/ensure-dirs.js";
+import { handleDecision } from "./commands/decision.js";
+import { handleLink } from "./commands/link.js";
+import { handleList } from "./commands/list.js";
+import { handleNode } from "./commands/node.js";
+import { handleTag } from "./commands/tag.js";
+import { exitWithError } from "./helpers.js";
+export async function runCli(resource, args) {
+  const DB_PATH = process.env.SODA_AGENT_TOOLS_DB ?? path.join(os.homedir(), ".soda-agent-tools", "data.db");
+  ensureDbDir(DB_PATH);
+  const db = new Database(DB_PATH);
+  try {
+    switch (resource) {
+      case "node":
+        await handleNode(db, args);
+        break;
+      case "tag":
+        await handleTag(db, args);
+        break;
+      case "link":
+        await handleLink(db, args);
+        break;
+      case "list":
+        await handleList(db, args);
+        break;
+      case "decision":
+        await handleDecision(db, args);
+        break;
+      default:
+        exitWithError(`Usage: sd <node|tag|link|list|tui|setup>
+
+Commands:
+  node    Create, read, update, delete, search nodes
+  tag     Add or remove tags
+  link    Create, delete, list links
+  list    List kinds or tags
+  tui     Launch the TUI browser
+  setup   Configure Claude Code integration`);
+    }
+  } catch (e) {
+    exitWithError(`Error: ${String(e instanceof Error ? e.message : e)}`);
+  } finally {
+    db.close();
+  }
+}

package/dist/src/cli.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env bun
+export {};
+const [, , command] = process.argv;
+switch (command) {
+  case "node":
+  case "tag":
+  case "link":
+  case "list":
+  case "decision": {
+    const { runCli } = await import("./cli/index.js");
+    await runCli(command, process.argv.slice(3));
+    break;
+  }
+  case "skill": {
+    const { handleSkill } = await import("./cli/commands/skill.js");
+    await handleSkill(process.argv.slice(3));
+    break;
+  }
+  case "agent": {
+    const { handleAgent } = await import("./cli/commands/agent.js");
+    await handleAgent(process.argv.slice(3));
+    break;
+  }
+  case "review": {
+    const { handleReview } = await import("./cli/commands/review.js");
+    await handleReview(process.argv.slice(3));
+    break;
+  }
+  case "codex-review": {
+    const { handleCodexReview } = await import("./cli/commands/codex-review.js");
+    await handleCodexReview(process.argv.slice(3));
+    break;
+  }
+  case "session": {
+    const { handleSession } = await import("./cli/commands/session.js");
+    await handleSession(process.argv.slice(3));
+    break;
+  }
+  case "tui":
+  case undefined:
+    await import("./tui/index.tsx");
+    break;
+  default:
+    console.error(`Usage: sd <node|tag|link|list|decision|skill|agent|review|codex-review|session|tui>
+
+Commands:
+  node          Create, read, update, delete, search nodes
+  tag           Add or remove tags
+  link          Create, delete, list links
+  list          List kinds or tags
+  decision      Create or list design decisions
+  skill         Print skill body
+  agent         Print agent body
+  review        Review utilities
+  codex-review  Run codex review
+  session       Session utilities
+  tui           Launch the TUI browser`);
+    process.exit(1);
+}