agnes-cli 0.0.1

package/src/ir.ts

@@ -0,0 +1,147 @@
+// Dialect-agnostic intermediate representation of a database schema.
+// Both the TS schema DSL and live-DB introspection are normalized into
+// DatabaseIR so push/pull/migrate can diff them structurally.
+
+export type ColumnType = "int" | "bigint" | "text" | "bool" | "float" | "bytes" | "json";
+
+export interface ColumnIR {
+  name: string;
+  type: ColumnType;
+  nullable: boolean;
+  primary: boolean;
+  /** default value as a literal; undefined = no default. */
+  default?: unknown;
+}
+
+export interface IndexIR {
+  name: string;
+  columns: string[];
+  unique: boolean;
+}
+
+export interface ForeignKeyIR {
+  /** Deterministic name so diff is stable. */
+  name: string;
+  column: string;
+  refTable: string;
+  refColumn: string;
+  onUpdate: string;
+  onDelete: string;
+}
+
+export interface TableIR {
+  name: string;
+  columns: ColumnIR[];
+  indexes: IndexIR[];
+  foreignKeys: ForeignKeyIR[];
+}
+
+/** Keyed by physical table name. */
+export type DatabaseIR = Record<string, TableIR>;
+
+// ─── Structural view of the schema DSL ──────────────────────────────────────
+// We treat the schema object duck-typed (via `_kind`) so the CLI never has to
+// share a compiled build with agnes-library — only the shape matters.
+
+interface DslColumn {
+  _kind: "column";
+  name: string;
+  type: ColumnType;
+  flags: {
+    primary?: boolean;
+    nullable?: boolean;
+    default?: unknown;
+    index?: { name: string; unique: boolean };
+  };
+}
+
+interface DslOneRelation {
+  _kind: "one";
+  target: string;
+  localKey: string;
+  targetKey: string;
+  onUpdate: string;
+  onDelete: string;
+}
+
+interface DslManyRelation {
+  _kind: "many";
+  target: string;
+  foreignKey: string;
+}
+
+type DslField = DslColumn | DslOneRelation | DslManyRelation;
+
+interface DslTableEntry {
+  def: Record<string, DslField>;
+  tableName: string;
+}
+
+export type DslSchema = Record<string, DslTableEntry>;
+
+function fkName(table: string, column: string): string {
+  return `fk_${table}_${column}`;
+}
+
+/** Resolve the physical column name of a DSL key inside a table def. */
+function colName(def: Record<string, DslField>, key: string): string | undefined {
+  const f = def[key];
+  return f && f._kind === "column" ? f.name : undefined;
+}
+
+/** Convert the user's schema DSL into the canonical DatabaseIR. */
+export function schemaToIR(schema: DslSchema): DatabaseIR {
+  // Map DSL table key → physical name for relation resolution.
+  const physicalName = new Map<string, string>();
+  for (const key in schema) physicalName.set(key, schema[key]!.tableName);
+
+  const ir: DatabaseIR = {};
+
+  for (const key in schema) {
+    const entry = schema[key]!;
+    const def = entry.def;
+    const columns: ColumnIR[] = [];
+    const indexes: IndexIR[] = [];
+    const foreignKeys: ForeignKeyIR[] = [];
+
+    for (const fieldKey in def) {
+      const field = def[fieldKey]!;
+      if (field._kind === "column") {
+        columns.push({
+          name: field.name,
+          type: field.type,
+          nullable: field.flags.nullable ?? false,
+          primary: field.flags.primary ?? false,
+          default: field.flags.default,
+        });
+        if (field.flags.index) {
+          indexes.push({
+            name: field.flags.index.name,
+            columns: [field.name],
+            unique: field.flags.index.unique,
+          });
+        }
+      } else if (field._kind === "one") {
+        const localCol = colName(def, field.localKey);
+        const targetDef = schema[field.target]?.def;
+        const refCol = targetDef ? colName(targetDef, field.targetKey) : undefined;
+        const refTable = physicalName.get(field.target);
+        if (localCol && refCol && refTable) {
+          foreignKeys.push({
+            name: fkName(entry.tableName, localCol),
+            column: localCol,
+            refTable,
+            refColumn: refCol,
+            onUpdate: field.onUpdate,
+            onDelete: field.onDelete,
+          });
+        }
+      }
+      // `many` relations have no physical footprint — the FK lives on the target side.
+    }
+
+    ir[entry.tableName] = { name: entry.tableName, columns, indexes, foreignKeys };
+  }
+
+  return ir;
+}

package/src/normalize.ts

@@ -0,0 +1,24 @@
+import { logicalType, physicalType, type Dialect } from "./dialect";
+import type { DatabaseIR } from "./ir";
+
+/**
+ * Project an IR into the lossy type space a given dialect actually stores, so a
+ * schema round-trips cleanly against introspection. Without this, e.g. SQLite
+ * (which stores `bool`/`bigint` as `integer`) would report a spurious diff on
+ * every `push`. Also enforces PK ⇒ NOT NULL on both sides.
+ */
+export function normalizeIR(ir: DatabaseIR, dialect: Dialect): DatabaseIR {
+  const out: DatabaseIR = {};
+  for (const name in ir) {
+    const t = ir[name]!;
+    out[name] = {
+      ...t,
+      columns: t.columns.map((c) => ({
+        ...c,
+        type: logicalType(physicalType(dialect, c.type)),
+        nullable: c.primary ? false : c.nullable,
+      })),
+    };
+  }
+  return out;
+}

package/src/print.ts

@@ -0,0 +1,74 @@
+import type { ColumnType, DatabaseIR, TableIR } from "./ir";
+
+const HELPER: Record<ColumnType, string> = {
+  int: "int",
+  bigint: "bigint",
+  text: "text",
+  bool: "bool",
+  float: "float",
+  bytes: "bytes",
+  json: "json",
+};
+
+const ON_ACTION: Record<string, string> = {
+  "NO ACTION": "OnAction.None",
+  RESTRICT: "OnAction.Restrict",
+  CASCADE: "OnAction.Cascade",
+  "SET NULL": "OnAction.SetNull",
+  "SET DEFAULT": "OnAction.SetDefault",
+};
+
+function onAction(rule: string): string {
+  return ON_ACTION[rule.toUpperCase()] ?? "OnAction.None";
+}
+
+function literal(v: unknown): string {
+  if (typeof v === "boolean") return String(v);
+  if (typeof v === "number" || typeof v === "bigint") return String(v);
+  return JSON.stringify(String(v));
+}
+
+function tableSource(t: TableIR): string {
+  const fkByColumn = new Map(t.foreignKeys.map((fk) => [fk.column, fk]));
+  const lines: string[] = [];
+
+  for (const col of t.columns) {
+    let expr = `${HELPER[col.type]}(${JSON.stringify(col.name)})`;
+    if (col.primary) expr += ".primary()";
+    else if (col.nullable) expr += ".nullable()";
+    if (col.default !== undefined) expr += `.default(${literal(col.default)})`;
+    for (const idx of t.indexes) {
+      if (idx.columns.length === 1 && idx.columns[0] === col.name) {
+        expr += idx.unique
+          ? `.uniqueIndex(${JSON.stringify(idx.name)})`
+          : `.index(${JSON.stringify(idx.name)})`;
+      }
+    }
+    lines.push(`    ${col.name}: ${expr},`);
+  }
+
+  for (const fk of fkByColumn.values()) {
+    // Relation TS key: derive from referenced table (best effort).
+    const relKey = fk.refTable;
+    lines.push(
+      `    ${relKey}: one(${JSON.stringify(fk.refTable)}, ${JSON.stringify(fk.column)}, ` +
+        `${JSON.stringify(fk.refColumn)}, ${onAction(fk.onUpdate)}, ${onAction(fk.onDelete)}),`,
+    );
+  }
+
+  return `  ${t.name}: table({\n${lines.join("\n")}\n  }, ${JSON.stringify(t.name)}),`;
+}
+
+/** Render a full DatabaseIR into schema.ts source code. */
+export function printSchema(ir: DatabaseIR): string {
+  const tables = Object.values(ir)
+    .sort((a, b) => a.name.localeCompare(b.name))
+    .map(tableSource)
+    .join("\n");
+
+  return (
+    `// Generated by \`agnes pull\`. Edit and re-run \`agnes push\` to apply changes.\n` +
+    `import { table, int, bigint, text, bool, float, bytes, json, one, OnAction } from "agnes-library";\n\n` +
+    `export const schema = {\n${tables}\n};\n`
+  );
+}

package/src/prompt.ts

@@ -0,0 +1,25 @@
+// Tiny ANSI + interactive-confirm helpers. No external deps.
+
+const useColor = process.stdout.isTTY && process.env.NO_COLOR === undefined;
+
+function paint(code: string, s: string): string {
+  return useColor ? `\x1b[${code}m${s}\x1b[0m` : s;
+}
+
+export const c = {
+  green: (s: string) => paint("32", s),
+  red: (s: string) => paint("31", s),
+  yellow: (s: string) => paint("33", s),
+  cyan: (s: string) => paint("36", s),
+  dim: (s: string) => paint("2", s),
+  bold: (s: string) => paint("1", s),
+};
+
+/** Ask a yes/no question. Returns true only on explicit y/yes. */
+export async function confirm(question: string): Promise<boolean> {
+  process.stdout.write(`${question} ${c.dim("[y/N]")} `);
+  for await (const line of console) {
+    return /^y(es)?$/i.test(line.trim());
+  }
+  return false;
+}