@staff0rd/assist 0.315.1 → 0.316.0

package/README.md

@@ -145,8 +145,8 @@ The first backlog command in a repository that still has a local `.assist/backlo
 - `assist backlog phase-done <id> <phase> <summary>` - Signal that a plan phase is complete with a summary (used by orchestrator)
 - `assist backlog rewind <id> <phase> --reason <reason>` - Rewind a backlog item to an earlier phase, setting status to in-progress
 - `assist backlog run <id>` - Run a backlog item's plan phase-by-phase with Claude; `--resume-session <id>` resumes an interrupted Claude session for the current phase (used by the sessions daemon when it restarts a running item)
-- `assist backlog export [file]` - Export the entire backlog database (all tables, all repos) to a file, or stdout if omitted
-- `assist backlog import [file]` - Restore the entire backlog database from a dump (file or stdin), faithfully replacing all data; prompts for confirmation (use `-y, --yes` to skip; required when reading from stdin)
+- `assist backlog export [file]` - Export every table in the backlog database (discovered by live schema introspection, so new tables are covered automatically) to a file, or stdout if omitted
+- `assist backlog import [file]` - Restore every table present in a dump (file or stdin) back into the backlog database in foreign-key-safe order, faithfully replacing all data and resyncing identity sequences; prompts for confirmation (use `-y, --yes` to skip; required when reading from stdin)
 - `assist backlog move-repo <old-origin> [new-origin]` - Retag all items from one origin to another after a repo rename; the new origin defaults to the current repo's remote, both accept URL or `git@` forms, and a bare repo name works for the old origin when unambiguous. Prompts for confirmation (use `-y, --yes` to skip)
 - `assist backlog web [-p, --port <number>] [--no-open]` - Open the backlog tab in the web dashboard (default port 3100); `--no-open` skips opening a browser on startup
 - `assist roam auth` - Authenticate with Roam via OAuth (opens browser, saves tokens to ~/.assist.yml)

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.315.1",
+  version: "0.316.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -3391,40 +3391,17 @@ import chalk29 from "chalk";
 // src/commands/backlog/dump/DumpTable.ts
 var DUMP_FORMAT = "assist-backlog-dump";
 var DUMP_VERSION = 1;
-var DUMP_TABLES = [
-  {
-    name: "items",
-    columns: [
-      "id",
-      "origin",
-      "type",
-      "name",
-      "description",
-      "acceptance_criteria",
-      "status",
-      "current_phase"
-    ]
-  },
-  {
-    name: "comments",
-    columns: ["id", "item_id", "idx", "text", "phase", "timestamp", "type"]
-  },
-  { name: "links", columns: ["item_id", "type", "target_id"] },
-  { name: "plan_phases", columns: ["item_id", "idx", "name", "manual_checks"] },
-  { name: "plan_tasks", columns: ["item_id", "phase_idx", "idx", "task"] },
-  { name: "metadata", columns: ["key", "value"] }
-];
 
 // src/commands/backlog/dump/buildDump.ts
-async function buildDump(copyOut) {
+async function buildDump(tables, copyOut) {
   const header = JSON.stringify({
     format: DUMP_FORMAT,
     version: DUMP_VERSION,
-    tables: DUMP_TABLES.map(({ name, columns }) => ({ name, columns }))
+    tables: tables.map(({ name, columns }) => ({ name, columns }))
   });
   const parts = [Buffer.from(`${header}
 `, "utf8")];
-  for (const table of DUMP_TABLES) {
+  for (const table of tables) {
     const data = await copyOut(table);
     parts.push(Buffer.from(`@table ${table.name} ${data.length}
 `, "utf8"));
@@ -3445,11 +3422,95 @@ async function copyTableOut(client, table) {
   return Buffer.concat(chunks);
 }
 
+// src/commands/backlog/dump/groupColumns.ts
+function groupColumns(rows) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const { table_name, quoted_table, quoted_column } of rows) {
+    let entry = byName.get(table_name);
+    if (!entry) {
+      entry = { raw: table_name, table: { name: quoted_table, columns: [] } };
+      byName.set(table_name, entry);
+    }
+    entry.table.columns.push(quoted_column);
+  }
+  return [...byName.values()];
+}
+
+// src/commands/backlog/dump/orderDumpTables.ts
+function buildGraph(names, edges) {
+  const present = new Set(names);
+  const indegree = new Map(names.map((n) => [n, 0]));
+  const children = /* @__PURE__ */ new Map();
+  for (const { child, parent } of edges) {
+    if (!present.has(child) || !present.has(parent)) continue;
+    indegree.set(child, (indegree.get(child) ?? 0) + 1);
+    children.set(parent, [...children.get(parent) ?? [], child]);
+  }
+  return { indegree, children };
+}
+function nextReady(names, emitted, indegree) {
+  return names.find((n) => !emitted.has(n) && (indegree.get(n) ?? 0) === 0);
+}
+function topoSort(entries, edges) {
+  const names = entries.map((e) => e.raw);
+  const { indegree, children } = buildGraph(names, edges);
+  const byRaw = new Map(entries.map((e) => [e.raw, e.table]));
+  const ordered = [];
+  const emitted = /* @__PURE__ */ new Set();
+  while (ordered.length < entries.length) {
+    const next3 = nextReady(names, emitted, indegree);
+    if (!next3)
+      throw new Error("Cannot dump: foreign-key cycle between tables.");
+    emitted.add(next3);
+    ordered.push(byRaw.get(next3));
+    for (const child of children.get(next3) ?? []) {
+      indegree.set(child, (indegree.get(child) ?? 0) - 1);
+    }
+  }
+  return ordered;
+}
+function orderDumpTables(columnRows, fkRows) {
+  return topoSort(groupColumns(columnRows), fkRows);
+}
+
+// src/commands/backlog/dump/introspectDumpTables.ts
+var COLUMNS_SQL = `
+	SELECT
+		c.table_name AS table_name,
+		quote_ident(c.table_name) AS quoted_table,
+		quote_ident(c.column_name) AS quoted_column
+	FROM information_schema.columns c
+	JOIN information_schema.tables t
+		ON t.table_schema = c.table_schema
+		AND t.table_name = c.table_name
+	WHERE c.table_schema = 'public'
+		AND t.table_type = 'BASE TABLE'
+	ORDER BY c.table_name, c.ordinal_position
+`;
+var FK_SQL = `
+	SELECT child.relname AS child, parent.relname AS parent
+	FROM pg_constraint con
+	JOIN pg_class child ON child.oid = con.conrelid
+	JOIN pg_class parent ON parent.oid = con.confrelid
+	JOIN pg_namespace n ON n.oid = con.connamespace
+	WHERE con.contype = 'f'
+		AND n.nspname = 'public'
+		AND con.conrelid <> con.confrelid
+`;
+async function introspectDumpTables(client) {
+  const [{ rows: columnRows }, { rows: fkRows }] = await Promise.all([
+    client.query(COLUMNS_SQL),
+    client.query(FK_SQL)
+  ]);
+  return orderDumpTables(columnRows, fkRows);
+}
+
 // src/commands/backlog/export/index.ts
 async function exportBacklog(file) {
-  const dump = await withDbClient(
-    (client) => buildDump((table) => copyTableOut(client, table))
-  );
+  const dump = await withDbClient(async (client) => {
+    const tables = await introspectDumpTables(client);
+    return buildDump(tables, (table) => copyTableOut(client, table));
+  });
   if (file) {
     await writeFile(file, dump);
     console.error(
@@ -6573,7 +6634,7 @@ function registerCommentCommands(cmd) {
 // src/commands/backlog/registerExportCommand.ts
 function registerExportCommand(cmd) {
   cmd.command("export [file]").description(
-    "Export the entire backlog database to a file, or stdout if omitted"
+    "Export every table in the backlog database (discovered by introspection) to a file, or stdout if omitted"
   ).action(exportBacklog);
 }
 
@@ -6631,11 +6692,9 @@ function parseDump(dump) {
 }
 
 // src/commands/backlog/dump/validateDump.ts
-function tableShape(tables) {
-  return JSON.stringify(tables.map(({ name, columns }) => ({ name, columns })));
-}
 function validateDump({ header, sections }) {
-  const missing = DUMP_TABLES.find(({ name }) => !sections.has(name))?.name;
+  const tables = header.tables ?? [];
+  const missing = tables.find(({ name }) => !sections.has(name))?.name;
   const checks = [
     [
       header.format === DUMP_FORMAT,
@@ -6645,10 +6704,7 @@ function validateDump({ header, sections }) {
       header.version === DUMP_VERSION,
       `Unsupported dump version ${header.version} (this build restores version ${DUMP_VERSION}).`
     ],
-    [
-      tableShape(header.tables ?? []) === tableShape(DUMP_TABLES),
-      "Dump table set does not match this build's backlog schema; cannot restore."
-    ],
+    [tables.length > 0, "Dump header lists no tables; cannot restore."],
     [!missing, `Invalid dump: missing data section for "${missing}".`]
   ];
   const failure = checks.find(([ok]) => !ok);
@@ -6663,24 +6719,24 @@ async function countRows(client, table) {
   );
   return rows[0].n;
 }
-function printSummary(current, incoming) {
-  const lines = DUMP_TABLES.map(
+function printSummary(tables, current, incoming) {
+  const lines = tables.map(
     (t, i) => `  ${t.name}: ${current[i]} \u2192 ${incoming[i]} rows`
   );
   console.error(chalk57.bold("\nThis will REPLACE all backlog data:"));
   console.error(`${lines.join("\n")}
 `);
 }
-async function confirmReplace(client, incoming, fromStdin) {
+async function confirmReplace(client, tables, incoming, fromStdin) {
   if (fromStdin) {
     throw new Error(
       "Reading a dump from stdin requires --yes (stdin is consumed by the dump)."
     );
   }
   const current = await Promise.all(
-    DUMP_TABLES.map((t) => countRows(client, t.name))
+    tables.map((t) => countRows(client, t.name))
   );
-  printSummary(current, incoming);
+  printSummary(tables, current, incoming);
   return promptConfirm("Replace all backlog data with this dump?", false);
 }
 
@@ -6703,23 +6759,48 @@ async function copyTableIn(client, table, data) {
   await finished(stream);
 }
 
-// src/commands/backlog/import/restore.ts
-var IDENTITY_TABLES = ["items", "comments"];
-function resyncIdentitySql(table) {
-  return `SELECT setval(pg_get_serial_sequence('${table}', 'id'),
-		GREATEST(COALESCE((SELECT max(id) FROM ${table}), 0), 1),
-		(SELECT count(*) FROM ${table}) > 0)`;
+// src/commands/backlog/dump/introspectIdentityColumns.ts
+var IDENTITY_SQL = `
+	SELECT
+		quote_ident(table_name) AS table,
+		quote_ident(column_name) AS column,
+		column_name AS raw_column
+	FROM information_schema.columns
+	WHERE table_schema = 'public'
+		AND is_identity = 'YES'
+	ORDER BY table_name, ordinal_position
+`;
+async function introspectIdentityColumns(client) {
+  const { rows } = await client.query(IDENTITY_SQL);
+  return rows.map((row) => ({
+    table: row.table,
+    column: row.column,
+    rawColumn: row.raw_column
+  }));
+}
+function resyncIdentitySql(col) {
+  return {
+    text: `SELECT setval(
+			pg_get_serial_sequence($1, $2),
+			GREATEST(COALESCE((SELECT max(${col.column}) FROM ${col.table}), 0), 1),
+			(SELECT count(*) FROM ${col.table}) > 0)`,
+    values: [col.table, col.rawColumn]
+  };
 }
+
+// src/commands/backlog/import/restore.ts
 async function replaceData(client, parsed) {
-  const tables = DUMP_TABLES.map((t) => t.name).join(", ");
+  const { tables } = parsed.header;
+  const tableList = tables.map((t) => t.name).join(", ");
   await client.query(SCHEMA);
-  await client.query(`TRUNCATE ${tables} RESTART IDENTITY CASCADE`);
-  for (const table of DUMP_TABLES) {
+  await client.query(`TRUNCATE ${tableList} RESTART IDENTITY CASCADE`);
+  for (const table of tables) {
     const data = parsed.sections.get(table.name) ?? Buffer.alloc(0);
     await copyTableIn(client, table, data);
   }
-  for (const table of IDENTITY_TABLES) {
-    await client.query(resyncIdentitySql(table));
+  for (const col of await introspectIdentityColumns(client)) {
+    const { text: text6, values } = resyncIdentitySql(col);
+    await client.query(text6, values);
   }
 }
 async function restore(client, parsed) {
@@ -6738,11 +6819,12 @@ async function importBacklog(file, options2 = {}) {
   const raw = file ? await readFile(file) : await readStdinBuffer();
   const parsed = parseDump(raw);
   validateDump(parsed);
-  const incoming = DUMP_TABLES.map(
+  const { tables } = parsed.header;
+  const incoming = tables.map(
     (t) => countCopyRows(parsed.sections.get(t.name) ?? Buffer.alloc(0))
   );
   await withDbClient(async (client) => {
-    if (!options2.yes && !await confirmReplace(client, incoming, !file)) {
+    if (!options2.yes && !await confirmReplace(client, tables, incoming, !file)) {
       console.error(chalk58.yellow("Import cancelled; no changes made."));
       return;
     }
@@ -6750,7 +6832,7 @@ async function importBacklog(file, options2 = {}) {
     const total = incoming.reduce((sum, n) => sum + n, 0);
     console.error(
       chalk58.green(
-        `Imported backlog: ${total} rows restored across ${DUMP_TABLES.length} tables.`
+        `Imported backlog: ${total} rows restored across ${tables.length} tables.`
       )
     );
   });
@@ -6759,7 +6841,7 @@ async function importBacklog(file, options2 = {}) {
 // src/commands/backlog/registerImportCommand.ts
 function registerImportCommand(cmd) {
   cmd.command("import [file]").description(
-    "Restore the entire backlog database from a dump file, or stdin if omitted (destructive)"
+    "Restore every table in a dump back into the backlog database, in foreign-key-safe order, from a file or stdin if omitted (destructive)"
   ).option("-y, --yes", "Skip the confirmation prompt").action(
     (file, options2) => importBacklog(file, options2)
   );

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@staff0rd/assist",
-	"version": "0.315.1",
+	"version": "0.316.0",
 	"type": "module",
 	"main": "dist/index.js",
 	"bin": {