erdraft 0.0.0-stage → 0.0.1

package/dist/chunk-VSN3XJPO.js

@@ -0,0 +1,99 @@
+// src/core/schema.ts
+import { z } from "zod";
+var REFERENTIAL_ACTIONS = [
+  "cascade",
+  "restrict",
+  "no action",
+  "set null",
+  "set default"
+];
+var columnSchema = z.object({
+  name: z.string().min(1),
+  type: z.string().min(1),
+  nullable: z.boolean().default(true),
+  primaryKey: z.boolean().default(false),
+  unique: z.boolean().default(false),
+  default: z.string().optional(),
+  note: z.string().optional(),
+  shape: z.string().min(1).optional()
+});
+var columnChangeSchema = z.object({
+  name: z.string().min(1),
+  type: z.string().min(1),
+  nullable: z.boolean(),
+  primaryKey: z.boolean(),
+  unique: z.boolean(),
+  default: z.string().nullable(),
+  note: z.string().nullable(),
+  shape: z.string().min(1).nullable()
+}).partial();
+var foreignKeySchema = z.object({
+  name: z.string().min(1).optional(),
+  columns: z.array(z.string().min(1)).min(1),
+  table: z.string().min(1),
+  foreignColumns: z.array(z.string().min(1)).min(1),
+  onDelete: z.enum(REFERENTIAL_ACTIONS).optional()
+});
+var indexSchema = z.object({
+  name: z.string().min(1).optional(),
+  columns: z.array(z.string().min(1)).min(1),
+  unique: z.boolean().default(false)
+});
+var checkSchema = z.object({
+  name: z.string().min(1),
+  expression: z.string().min(1)
+});
+var tableSchema = z.object({
+  name: z.string().min(1),
+  note: z.string().optional(),
+  columns: z.array(columnSchema).min(1),
+  foreignKeys: z.array(foreignKeySchema).default([]),
+  indexes: z.array(indexSchema).default([]),
+  checks: z.array(checkSchema).default([])
+});
+var enumSchema = z.object({
+  name: z.string().min(1),
+  values: z.array(z.string().min(1)).min(1)
+});
+var schemaSchema = z.object({
+  tables: z.array(tableSchema),
+  enums: z.array(enumSchema)
+});
+function foreignKeyName(table, foreignKey) {
+  return foreignKey.name ?? `${table}_${foreignKey.columns.join("_")}_${foreignKey.table}_${foreignKey.foreignColumns.join("_")}_fk`;
+}
+function indexName(table, index) {
+  return index.name ?? `${table}_${index.columns.join("_")}_${index.unique ? "unique" : "index"}`;
+}
+function namedTable(table) {
+  return {
+    ...table,
+    foreignKeys: table.foreignKeys.map((foreignKey) => ({
+      ...foreignKey,
+      name: foreignKeyName(table.name, foreignKey)
+    })),
+    indexes: table.indexes.map((index) => ({
+      ...index,
+      name: indexName(table.name, index)
+    }))
+  };
+}
+function parseSchema(value) {
+  const schema = schemaSchema.parse(value);
+  return { tables: schema.tables.map(namedTable), enums: schema.enums };
+}
+
+export {
+  columnSchema,
+  columnChangeSchema,
+  foreignKeySchema,
+  indexSchema,
+  checkSchema,
+  tableSchema,
+  enumSchema,
+  schemaSchema,
+  foreignKeyName,
+  indexName,
+  namedTable,
+  parseSchema
+};

package/dist/cli.js

@@ -0,0 +1,507 @@
+#!/usr/bin/env node
+import {
+  DECISION_SECONDS,
+  chooseDatabase,
+  createApi,
+  createServer,
+  currentDatabase,
+  databaseOf,
+  describeDecision,
+  describeDraft,
+  describeTable,
+  describeTables,
+  draftLine,
+  readDraft,
+  readSchema,
+  storeOf,
+  version_default,
+  writtenIn
+} from "./chunk-SSLBX2OF.js";
+import "./chunk-VSN3XJPO.js";
+
+// bin/erdraft.ts
+import { fileURLToPath } from "url";
+import { existsSync } from "fs";
+import { join as join4 } from "path";
+import { text } from "stream/consumers";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server/serve-window.ts
+import { createServer as createServer2 } from "http";
+import { readFile, stat } from "fs/promises";
+import { extname, join } from "path";
+var TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2"
+};
+async function fileOf(folder, url) {
+  const { pathname } = new URL(String(url), "http://localhost");
+  const path = join(folder, pathname);
+  const found = await stat(path).catch(() => void 0);
+  return found?.isFile() ? path : join(folder, "index.html");
+}
+function refuse(response, status, message) {
+  response.writeHead(status, { "content-type": "text/plain; charset=utf-8" });
+  response.end(message);
+}
+async function serveWindow(config, folder) {
+  const api = createApi(config);
+  const server = createServer2((request, response) => {
+    api.middleware(request, response, (error) => {
+      if (error) {
+        refuse(response, 500, String(error));
+        return;
+      }
+      if (request.method !== "GET" && request.method !== "HEAD") {
+        refuse(response, 404, "Not found");
+        return;
+      }
+      fileOf(folder, request.url).then(async (path) => {
+        const body = await readFile(path);
+        response.writeHead(200, {
+          "content-type": TYPES[extname(path)] ?? "application/octet-stream"
+        });
+        response.end(body);
+      }).catch((failure) => refuse(response, 500, String(failure)));
+    });
+  });
+  server.on("close", api.close);
+  await new Promise((done, fail) => {
+    server.once("error", (error) => {
+      api.close();
+      fail(
+        error.code === "EADDRINUSE" ? new Error(
+          `Port ${config.port} is taken: stop what holds it, or give the window another "port" in .erdraft.json`
+        ) : error
+      );
+    });
+    server.listen(config.port, "127.0.0.1", done);
+  });
+  return server;
+}
+
+// src/cli/run.ts
+import { readFile as readFile4 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import { parseArgs } from "util";
+import { z as z2 } from "zod";
+
+// src/core/load-config.ts
+import { z } from "zod";
+import { join as join2, resolve, dirname, basename } from "path";
+import { homedir } from "os";
+import { readFile as readFile2 } from "fs/promises";
+import { createHash } from "crypto";
+var CONFIG_FILE = ".erdraft.json";
+var databaseSchema = z.object({
+  // The name the window's menu shows it by
+  name: z.string().min(1),
+  // The module of Drizzle that exports every table and enum (drizzle-kit's `schema`)
+  schema: z.string().min(1)
+});
+var configSchema = z.object({
+  // The project's name; none given, its folder's
+  name: z.string().min(1).optional(),
+  // The project's one database, its module of Drizzle; or its databases, each named, the window switching between
+  schema: z.string().min(1).optional(),
+  databases: z.array(databaseSchema).min(1).optional(),
+  // The folder Erdraft keeps the drafts in, shared by the CLI, the MCP and the window, and by every workspace of
+  // the project on the machine: `~` is the home folder; none given, ~/.erdraft/<the project's name>
+  store: z.string().min(1).optional(),
+  // The window's port
+  port: z.number().int().min(1).max(65535).default(9369),
+  // The window's assistant: the Claude Code it runs headless, and its model (an alias or a model's full name)
+  claude: z.string().min(1).default("claude"),
+  model: z.string().min(1).default("sonnet")
+});
+function folderOf(name) {
+  const folder = name.normalize("NFKD").replace(new RegExp("\\p{Diacritic}", "gu"), "").toLocaleLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return folder || createHash("sha256").update(name).digest("hex").slice(0, 12);
+}
+function storeOf2(folder, name, store) {
+  if (store === void 0) {
+    return join2(homedir(), ".erdraft", folderOf(name));
+  }
+  if (store === "~" || store.startsWith("~/")) {
+    return join2(homedir(), store.slice(1));
+  }
+  return resolve(folder, store);
+}
+function parsed(path, text2) {
+  try {
+    return configSchema.parse(JSON.parse(text2));
+  } catch (error) {
+    throw new Error(
+      `${path} is not a config Erdraft reads: ${error instanceof z.ZodError ? z.prettifyError(error) : String(error)}`
+    );
+  }
+}
+async function readIfThere(path) {
+  try {
+    return await readFile2(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+async function loadConfig(from) {
+  let folder = resolve(from);
+  for (; ; ) {
+    const text2 = await readIfThere(join2(folder, CONFIG_FILE));
+    if (text2 !== void 0) {
+      const {
+        schema,
+        databases,
+        name = basename(folder),
+        ...config
+      } = parsed(join2(folder, CONFIG_FILE), text2);
+      const [first, ...rest] = (databases ?? (schema ? [{ name, schema }] : [])).map((database) => ({
+        id: folderOf(database.name),
+        name: database.name,
+        schema: resolve(folder, database.schema)
+      }));
+      if (!first) {
+        throw new Error(`${CONFIG_FILE} names no schema nor databases`);
+      }
+      const ids = new Set([first, ...rest].map((database) => database.id));
+      if (ids.size !== rest.length + 1) {
+        throw new Error(`${CONFIG_FILE} names two databases alike`);
+      }
+      return {
+        ...config,
+        name,
+        databases: [first, ...rest],
+        store: storeOf2(folder, name, config.store),
+        root: folder,
+        workspace: createHash("sha256").update(folder).digest("hex").slice(0, 12)
+      };
+    }
+    const parent = dirname(folder);
+    if (parent === folder) {
+      throw new Error(`No ${CONFIG_FILE} in ${resolve(from)} or above it`);
+    }
+    folder = parent;
+  }
+}
+
+// src/core/install-skill.ts
+import { mkdir, readFile as readFile3, writeFile } from "fs/promises";
+import { dirname as dirname2, join as join3 } from "path";
+var SKILL_PATH = join3(".claude", "skills", "erdraft", "SKILL.md");
+async function readIfThere2(path) {
+  try {
+    return await readFile3(path, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function installSkill(root, source, force = false) {
+  const path = join3(root, SKILL_PATH);
+  const skill = await readFile3(source, "utf8");
+  const there = await readIfThere2(path);
+  if (there === skill) {
+    return { path, written: false };
+  }
+  if (there !== void 0 && !force) {
+    throw new Error(
+      `${SKILL_PATH} differs from this Erdraft's skill (changed, or of another version): --force writes it over`
+    );
+  }
+  await mkdir(dirname2(path), { recursive: true });
+  await writeFile(path, skill);
+  return { path, written: true };
+}
+
+// src/cli/run.ts
+var HELP = `erdraft: a project's data model, drafted with an agent while a person watches
+
+Usage: erdraft <command> [options] [--database <id>]
+       erdraft --version
+
+  studio                      Open the window (the diagram, live)
+  mcp                         Serve the MCP on stdin and stdout, for an agent
+  read                        Read the schema again from the code
+  tables [--draft <id>]       List the tables
+  table <name> [--draft <id>] Describe a table
+  drafts                      List the drafts
+  draft <id>                  Show a draft and what it changes
+  propose <file|-> --title <title> [--summary <text>] [--group <name>]
+                              Propose a draft from a JSON array of operations
+  revise <id> [<file|->] [--replace] [--title <title>] [--summary <text>] [--group <name>]
+                              Add operations to a draft (or put them in its place)
+  show [<table>] [--related] [--draft <id> | --schema]
+                              Show it in the window: a table in focus, only it and the tables it joins, a draft
+  wait <id> [--seconds <n>]   Wait until the person adopts a draft or sets it aside (30 s at most when not said)
+  adopt <id>                  Adopt a draft (the others of its group are set aside)
+  discard <id>                Set a draft aside
+  delete <id>                 Delete a draft for good
+  databases                   List the project's databases, * the one worked on
+  install-skill [--force]     Write Erdraft's skill into the project (.claude/skills/erdraft), for its agents
+  use <id>                    Work on another database (the window switches too)
+
+A command works on the database chosen last (use), or on the one --database names. The nearest .erdraft.json says
+where the databases' schemas and their drafts are.`;
+async function operationsFrom(path, options) {
+  if (path === void 0) {
+    return void 0;
+  }
+  const text2 = path === "-" ? await options.stdin() : await readFile4(resolve2(options.cwd, path), "utf8");
+  return JSON.parse(text2);
+}
+function required(value, what) {
+  if (!value) {
+    throw new Error(`Missing ${what}. Run erdraft --help`);
+  }
+  return value;
+}
+async function command(argv, options) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      draft: { type: "string" },
+      title: { type: "string" },
+      summary: { type: "string" },
+      group: { type: "string" },
+      replace: { type: "boolean" },
+      related: { type: "boolean" },
+      schema: { type: "boolean" },
+      database: { type: "string" },
+      seconds: { type: "string" },
+      force: { type: "boolean" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" }
+    }
+  });
+  const [name, argument] = positionals;
+  if (values.version) {
+    options.out(version_default);
+    return;
+  }
+  if (!name || values.help) {
+    options.out(HELP);
+    return;
+  }
+  const config = await loadConfig(options.cwd);
+  const database = values.database ? databaseOf(config, values.database) : await currentDatabase(config);
+  const drafts = storeOf(config, database);
+  async function base() {
+    return await drafts.readBase() ?? readSchema(config, database, drafts);
+  }
+  async function readOf(draft) {
+    return readDraft(
+      (await base()).schema,
+      draft ? (await drafts.draft(draft)).operations : []
+    );
+  }
+  async function schemaOf(draft) {
+    return (await readOf(draft)).diff;
+  }
+  switch (name) {
+    case "studio":
+      await readSchema(config, database, drafts);
+      return options.startStudio(config);
+    case "mcp":
+      return options.startMcp(config);
+    case "read": {
+      const base2 = await readSchema(config, database, drafts);
+      options.out(
+        `Read ${base2.schema.tables.length} tables and ${base2.schema.enums.length} enums from ${base2.source}.`
+      );
+      return;
+    }
+    case "tables":
+      options.out(describeTables(await schemaOf(values.draft)));
+      return;
+    case "table": {
+      const tableName = required(argument, "the table\u2019s name");
+      const diff = await schemaOf(values.draft);
+      const table = diff.tables.find((each) => each.name === tableName);
+      if (!table) {
+        throw new Error(`There is no table "${tableName}"`);
+      }
+      options.out(describeTable(table, diff));
+      return;
+    }
+    case "drafts": {
+      const all = await drafts.readDrafts();
+      options.out(
+        all.length > 0 ? all.map(draftLine).join("\n") : "No drafts yet."
+      );
+      return;
+    }
+    case "draft": {
+      const draft = await drafts.draft(required(argument, "the draft\u2019s id"));
+      const { diff, written } = await readOf(draft.id);
+      options.out(describeDraft(draft, diff, written));
+      return;
+    }
+    case "propose": {
+      await base();
+      const operations = await operationsFrom(
+        required(argument, "the operations\u2019 file"),
+        options
+      );
+      const draft = await drafts.propose({
+        title: required(values.title, "--title"),
+        summary: values.summary,
+        group: values.group,
+        operations
+      });
+      options.out(`Proposed ${draft.id}: ${draft.title}.`);
+      return;
+    }
+    case "revise": {
+      await base();
+      const id = required(argument, "the draft\u2019s id");
+      const operations = await operationsFrom(positionals[2], options);
+      const draft = await drafts.revise(id, {
+        title: values.title,
+        summary: values.summary,
+        group: values.group,
+        mode: values.replace ? "replace" : "append",
+        operations
+      });
+      options.out(`Revised ${draft.id}: ${draft.title}.`);
+      return;
+    }
+    case "show": {
+      const draft = values.schema ? null : values.draft;
+      const diff = await schemaOf(draft ?? void 0);
+      if (argument && !diff.tables.some((each) => each.name === argument)) {
+        throw new Error(`There is no table "${argument}"`);
+      }
+      await drafts.show({
+        table: argument ?? null,
+        related: values.related === true && argument !== void 0,
+        draft
+      });
+      options.out(`Shown in the window.`);
+      return;
+    }
+    case "wait": {
+      const seconds = Number(values.seconds ?? DECISION_SECONDS);
+      if (!Number.isInteger(seconds) || seconds < 1) {
+        throw new Error("--seconds is a whole number of seconds, 1 or more");
+      }
+      const draft = await drafts.decision(
+        required(argument, "the draft\u2019s id"),
+        seconds * 1e3
+      );
+      options.out(
+        describeDecision(
+          draft,
+          await drafts.readDrafts(),
+          seconds,
+          writtenIn((await base()).schema, draft.operations)
+        )
+      );
+      return;
+    }
+    case "adopt":
+    case "discard": {
+      const draft = await drafts.setStatus(
+        required(argument, "the draft\u2019s id"),
+        name === "adopt" ? "adopted" : "discarded"
+      );
+      options.out(
+        `${name === "adopt" ? "Adopted" : "Discarded"} ${draft.id}: ${draft.title}.`
+      );
+      return;
+    }
+    case "delete": {
+      const draft = await drafts.deleteDraft(
+        required(argument, "the draft\u2019s id")
+      );
+      options.out(`Deleted ${draft.id}: ${draft.title}.`);
+      return;
+    }
+    case "databases":
+      options.out(
+        config.databases.map(
+          (each) => `${each.id === database.id ? "*" : " "} ${each.id}  ${each.name}`
+        ).join("\n")
+      );
+      return;
+    case "install-skill": {
+      const { path, written } = await installSkill(
+        config.root,
+        options.skill,
+        values.force
+      );
+      options.out(
+        written ? `Wrote Erdraft's skill to ${path}.` : `Erdraft's skill is already in ${path}, the same.`
+      );
+      return;
+    }
+    case "use": {
+      const chosen = await chooseDatabase(
+        config,
+        required(argument, "the database\u2019s id")
+      );
+      options.out(`Working on ${chosen.name}.`);
+      return;
+    }
+    default:
+      throw new Error(`Unknown command "${name}". Run erdraft --help`);
+  }
+}
+var ERROR_NAME = /^\w*Error(?: \[\w+\])?: /;
+async function run(argv, options) {
+  try {
+    await command(argv, options);
+    return 0;
+  } catch (error) {
+    options.err(
+      error instanceof z2.ZodError ? z2.prettifyError(error) : String(error).replace(ERROR_NAME, "")
+    );
+    return 1;
+  }
+}
+
+// bin/erdraft.ts
+var WINDOW = fileURLToPath(new URL("./window", import.meta.url));
+async function listen(config) {
+  if (existsSync(join4(WINDOW, "index.html"))) {
+    return serveWindow(config, WINDOW);
+  }
+  const [{ createServer: createServer3 }, { default: studioConfig }] = await Promise.all([
+    import("vite"),
+    import("./studio-config-TIVT4MNY.js")
+  ]);
+  const server = await createServer3(studioConfig(config));
+  await server.listen();
+  return server.httpServer;
+}
+var code = await run(process.argv.slice(2), {
+  cwd: process.cwd(),
+  skill: fileURLToPath(new URL("../skill/SKILL.md", import.meta.url)),
+  out: (value) => process.stdout.write(`${value}
+`),
+  err: (value) => process.stderr.write(`${value}
+`),
+  stdin: () => text(process.stdin),
+  startMcp: async (config) => {
+    await createServer({ config }).connect(new StdioServerTransport());
+    await new Promise((done) => process.stdin.on("end", done));
+  },
+  startStudio: async (config) => {
+    const server = await listen(config);
+    process.stdout.write(
+      `Erdraft: ${config.name}'s data model at http://localhost:${config.port}
+`
+    );
+    await new Promise((done) => server?.on("close", done));
+  }
+});
+process.stderr.write(
+  "",
+  () => process.stdout.write("", () => process.exit(code))
+);