agent-standup 0.20.0

package/dist/run-init-VVQPJOTB.js

@@ -0,0 +1,407 @@
+#!/usr/bin/env node
+
+// scripts/lib/run-migrations.mjs
+import { spawn } from "node:child_process";
+var isWindows = process.platform === "win32";
+async function runMigrations({
+  cwd = process.cwd(),
+  env = process.env,
+  log = console,
+  schemaPath
+} = {}) {
+  log.info('Applying database migrations ("prisma migrate deploy")...');
+  const args = ["prisma", "migrate", "deploy"];
+  if (schemaPath) {
+    args.push("--schema", schemaPath);
+  }
+  const exitCode = await new Promise((resolve, reject) => {
+    const child = spawn(isWindows ? "npx.cmd" : "npx", args, {
+      cwd,
+      env,
+      stdio: "inherit",
+      shell: isWindows
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => resolve(code ?? 1));
+  });
+  if (exitCode !== 0) {
+    log.error(
+      `FATAL: database migration failed ("prisma migrate deploy" exited ${exitCode}) \u2014 refusing to start the application. See the Prisma output above for details.`
+    );
+    return { ok: false, exitCode };
+  }
+  log.info("Migrations applied successfully.");
+  return { ok: true, exitCode: 0 };
+}
+
+// scripts/lib/verify-round-trip.mjs
+import { PrismaClient } from "@prisma/client";
+var RoundTripFailedError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RoundTripFailedError";
+  }
+};
+async function verifyRoundTrip({ databaseUrl, log = console }) {
+  if (!databaseUrl) {
+    throw new RoundTripFailedError("No connection string was given to verify.");
+  }
+  const prisma = new PrismaClient({ datasourceUrl: databaseUrl });
+  const marker = `standup-init-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  try {
+    await prisma.$executeRawUnsafe(
+      `CREATE TEMP TABLE "standup_init_round_trip" ("value" text NOT NULL)`
+    );
+    await prisma.$executeRawUnsafe(
+      `INSERT INTO "standup_init_round_trip" ("value") VALUES ($1)`,
+      marker
+    );
+    const rows = await prisma.$queryRawUnsafe(`SELECT "value" FROM "standup_init_round_trip"`);
+    if (!Array.isArray(rows) || rows.length !== 1 || rows[0]?.value !== marker) {
+      throw new RoundTripFailedError(
+        "The value read back did not match the value written \u2014 the connection accepted the write but did not return it faithfully."
+      );
+    }
+    log.info("Live round trip succeeded: wrote a row and read it back unchanged.");
+  } catch (cause) {
+    if (cause instanceof RoundTripFailedError) throw cause;
+    throw new RoundTripFailedError("Could not complete a write-then-read against the database.", {
+      cause
+    });
+  } finally {
+    await prisma.$disconnect().catch(() => {
+    });
+  }
+}
+
+// scripts/lib/provision-db.mjs
+import { spawnSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+var isWindows2 = process.platform === "win32";
+var SAFE_IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var InvalidIdentifierError = class extends Error {
+  constructor(kind, value) {
+    super(
+      `${kind} ${JSON.stringify(value)} is not a safe identifier \u2014 only letters, digits and underscore, not starting with a digit, are accepted.`
+    );
+    this.name = "InvalidIdentifierError";
+  }
+};
+function assertSafeIdentifier(kind, value) {
+  if (typeof value !== "string" || !SAFE_IDENTIFIER.test(value)) {
+    throw new InvalidIdentifierError(kind, value);
+  }
+  return value;
+}
+function quoteLiteral(value) {
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+function generatePassword() {
+  return randomBytes(24).toString("hex");
+}
+function withDatabaseName(url, name) {
+  const parsed = new URL(url);
+  parsed.pathname = `/${name}`;
+  return parsed.toString();
+}
+function buildAppUrl(provisionUrl, { databaseName, appRole, appPassword }) {
+  const parsed = new URL(provisionUrl);
+  parsed.username = encodeURIComponent(appRole);
+  parsed.password = encodeURIComponent(appPassword);
+  parsed.pathname = `/${databaseName}`;
+  parsed.search = "";
+  return parsed.toString();
+}
+function execute(url, sql) {
+  const result = spawnSync(
+    isWindows2 ? "npx.cmd" : "npx",
+    ["prisma", "db", "execute", "--url", url, "--stdin"],
+    { input: sql, encoding: "utf-8", shell: isWindows2 }
+  );
+  if (result.status === 0) return { ok: true };
+  const output = `${result.stderr ?? ""}${result.stdout ?? ""}`;
+  const alreadyExists = /already exists/i.test(output);
+  return { ok: false, alreadyExists, output };
+}
+function ensureDatabase(provisionUrl, databaseName, log = console) {
+  assertSafeIdentifier("database name", databaseName);
+  const adminUrl = withDatabaseName(provisionUrl, "postgres");
+  const result = execute(adminUrl, `CREATE DATABASE "${databaseName}";`);
+  if (result.ok) {
+    log.info(`Created database "${databaseName}".`);
+    return;
+  }
+  if (result.alreadyExists) {
+    log.info(`Database "${databaseName}" already exists; leaving it as it is.`);
+    return;
+  }
+  throw new Error(`Could not create database "${databaseName}" (see prisma's own output above).`);
+}
+function ensureAppRole(provisionUrl, appRole, appPassword, log = console) {
+  assertSafeIdentifier("application role", appRole);
+  const adminUrl = withDatabaseName(provisionUrl, "postgres");
+  const sql = `
+DO $$
+BEGIN
+  IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname = ${quoteLiteral(appRole)}) THEN
+    CREATE ROLE "${appRole}" WITH LOGIN PASSWORD ${quoteLiteral(appPassword)};
+  ELSE
+    ALTER ROLE "${appRole}" WITH LOGIN PASSWORD ${quoteLiteral(appPassword)};
+  END IF;
+END
+$$;`;
+  const result = execute(adminUrl, sql);
+  if (!result.ok) {
+    throw new Error(
+      `Could not create or update role "${appRole}" (see prisma's own output above).`
+    );
+  }
+  log.info(`Application role "${appRole}" is ready.`);
+}
+function grantAppRole(provisionUrl, databaseName, appRole, log = console) {
+  assertSafeIdentifier("database name", databaseName);
+  assertSafeIdentifier("application role", appRole);
+  const targetUrl = withDatabaseName(provisionUrl, databaseName);
+  const statements = [
+    `GRANT CONNECT ON DATABASE "${databaseName}" TO "${appRole}";`,
+    `GRANT USAGE ON SCHEMA public TO "${appRole}";`,
+    `GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO "${appRole}";`,
+    `GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO "${appRole}";`,
+    `ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO "${appRole}";`,
+    `ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT USAGE, SELECT ON SEQUENCES TO "${appRole}";`
+  ];
+  for (const sql of statements) {
+    const result = execute(targetUrl, sql);
+    if (!result.ok) {
+      throw new Error(
+        `Could not grant privileges to role "${appRole}" (see prisma's own output above).`
+      );
+    }
+  }
+  log.info(`Granted "${appRole}" read/write on "${databaseName}".`);
+}
+function provisionAppDatabase({
+  provisionUrl,
+  databaseName,
+  appRole,
+  appPassword,
+  log = console
+}) {
+  const password = appPassword ?? generatePassword();
+  ensureDatabase(provisionUrl, databaseName, log);
+  ensureAppRole(provisionUrl, appRole, password, log);
+  grantAppRole(provisionUrl, databaseName, appRole, log);
+  return {
+    appUrl: buildAppUrl(provisionUrl, { databaseName, appRole, appPassword: password }),
+    migrateUrl: withDatabaseName(provisionUrl, databaseName),
+    generatedPassword: appPassword === void 0
+  };
+}
+
+// scripts/lib/container-provision.mjs
+import { spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
+
+// scripts/lib/boot-env.mjs
+var DEFAULT_DB_WAIT_TIMEOUT_SECONDS = 180;
+var DEFAULT_DB_WAIT_INTERVAL_SECONDS = 2;
+
+// scripts/lib/wait-for-db.mjs
+import { PrismaClient as PrismaClient2 } from "@prisma/client";
+var DatabaseUnreachableError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "DatabaseUnreachableError";
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function summarize(value) {
+  return String(value?.message ?? value).split("\n").map((line) => line.trim()).filter(Boolean).join(" ");
+}
+async function waitForDatabase({
+  databaseUrl,
+  timeoutMs = DEFAULT_DB_WAIT_TIMEOUT_SECONDS * 1e3,
+  intervalMs = DEFAULT_DB_WAIT_INTERVAL_SECONDS * 1e3,
+  log = console
+} = {}) {
+  if (!databaseUrl) {
+    throw new DatabaseUnreachableError("DATABASE_URL is not set.");
+  }
+  const deadline = Date.now() + timeoutMs;
+  let lastError;
+  let attempt = 0;
+  for (; ; ) {
+    attempt += 1;
+    const probe = new PrismaClient2({ datasourceUrl: databaseUrl });
+    try {
+      await probe.$queryRaw`SELECT 1`;
+      await probe.$disconnect();
+      log.info(`Database reachable after ${attempt} attempt(s).`);
+      return;
+    } catch (err) {
+      lastError = err;
+      await probe.$disconnect().catch(() => {
+      });
+      const remaining = deadline - Date.now();
+      if (!Number.isFinite(remaining) || remaining <= 0) {
+        log.warn(`Database still not ready (attempt ${attempt}: ${summarize(err)}); giving up.`);
+        break;
+      }
+      log.warn(`Database not ready yet (attempt ${attempt}: ${summarize(err)}); retrying...`);
+      await sleep(Math.min(intervalMs, remaining));
+    }
+  }
+  throw new DatabaseUnreachableError(
+    `Database still unreachable after ${timeoutMs}ms across ${attempt} attempt(s): ${summarize(lastError)}`,
+    { cause: lastError }
+  );
+}
+
+// scripts/lib/container-provision.mjs
+var isWindows3 = process.platform === "win32";
+var DEV_COMPOSE_PROVISION_URL = "postgres://standup:standup@localhost:5433/postgres";
+function dockerAvailable() {
+  const result = spawnSync2(isWindows3 ? "docker.exe" : "docker", ["compose", "version"], {
+    encoding: "utf-8",
+    shell: isWindows3
+  });
+  return result.status === 0;
+}
+async function attemptContainerProvision({
+  cwd = process.cwd(),
+  log = console,
+  timeoutMs = DEFAULT_DB_WAIT_TIMEOUT_SECONDS * 1e3,
+  intervalMs = DEFAULT_DB_WAIT_INTERVAL_SECONDS * 1e3
+} = {}) {
+  if (!dockerAvailable()) {
+    return { ok: false, reason: "No container runtime (`docker compose`) is available." };
+  }
+  const upExitCode = await new Promise((resolve) => {
+    const child = spawn2(isWindows3 ? "docker.exe" : "docker", ["compose", "up", "-d", "db"], {
+      cwd,
+      stdio: "inherit",
+      shell: isWindows3
+    });
+    child.on("error", () => resolve(1));
+    child.on("exit", (code) => resolve(code ?? 1));
+  });
+  if (upExitCode !== 0) {
+    return { ok: false, reason: "`docker compose up -d db` did not succeed." };
+  }
+  try {
+    await waitForDatabase({
+      databaseUrl: DEV_COMPOSE_PROVISION_URL,
+      timeoutMs,
+      intervalMs,
+      log
+    });
+  } catch (err) {
+    if (err instanceof DatabaseUnreachableError) {
+      return { ok: false, reason: "The container started but Postgres never became reachable." };
+    }
+    throw err;
+  }
+  return { ok: true, provisionUrl: DEV_COMPOSE_PROVISION_URL };
+}
+
+// scripts/lib/run-init.mjs
+import { spawn as spawn3 } from "node:child_process";
+function runSeed({ databaseUrl, cwd, env, log }) {
+  return new Promise((resolve) => {
+    log.info("Seeding reference data...");
+    const child = spawn3("node", ["prisma/seed.mjs"], {
+      cwd,
+      env: { ...env, DATABASE_URL: databaseUrl },
+      stdio: "inherit"
+    });
+    child.on("error", () => resolve({ ok: false }));
+    child.on("exit", (code) => resolve({ ok: (code ?? 1) === 0 }));
+  });
+}
+function describeDatabase(databaseUrl) {
+  const url = new URL(databaseUrl);
+  return {
+    host: url.hostname,
+    port: url.port || void 0,
+    name: url.pathname.replace(/^\//, "")
+  };
+}
+async function runInitSequence({
+  source,
+  cwd = process.cwd(),
+  env = process.env,
+  log = console
+}) {
+  let appUrl;
+  let migrateUrl;
+  let resultSource;
+  let appRole;
+  if (source.kind === "accept") {
+    appUrl = source.databaseUrl;
+    migrateUrl = source.databaseUrl;
+    resultSource = "accepted";
+  } else {
+    let provisionUrl = source.kind === "provision" ? source.provisionUrl : void 0;
+    if (source.kind === "auto") {
+      const attempt = await attemptContainerProvision({ cwd, log });
+      if (!attempt.ok) {
+        return {
+          ok: false,
+          stage: "container",
+          message: `Could not find or provision a database automatically (${attempt.reason}). Supply one with --database-url (a connection string to use directly) or --provision-url (an admin connection to provision a fresh database and role from), then run \`standup init\` again.`
+        };
+      }
+      provisionUrl = attempt.provisionUrl;
+    }
+    try {
+      const provisioned = provisionAppDatabase({
+        provisionUrl,
+        databaseName: source.databaseName,
+        appRole: source.appRole,
+        appPassword: source.appPassword,
+        log
+      });
+      appUrl = provisioned.appUrl;
+      migrateUrl = provisioned.migrateUrl;
+    } catch (cause) {
+      log.error("Provisioning the database and application role failed.", cause);
+      return {
+        ok: false,
+        stage: "provision",
+        message: "Could not provision the database and application role (see the output above)."
+      };
+    }
+    resultSource = source.kind === "auto" ? "provisioned-via-container" : "provisioned";
+    appRole = source.appRole;
+  }
+  const migration = await runMigrations({ env: { ...env, DATABASE_URL: migrateUrl }, cwd, log });
+  if (!migration.ok) {
+    return { ok: false, stage: "migrate", message: "Migrations did not apply cleanly." };
+  }
+  const seeded = await runSeed({ databaseUrl: appUrl, cwd, env, log });
+  if (!seeded.ok) {
+    return { ok: false, stage: "seed", message: "Seeding reference data failed." };
+  }
+  try {
+    await verifyRoundTrip({ databaseUrl: appUrl, log });
+  } catch {
+    return {
+      ok: false,
+      stage: "verify",
+      message: "Migrated and seeded, but the live round trip (write, then read it back) failed."
+    };
+  }
+  return {
+    ok: true,
+    databaseUrl: appUrl,
+    source: resultSource,
+    database: describeDatabase(appUrl),
+    ...appRole === void 0 ? {} : { appRole },
+    steps: { migrated: true, seeded: true, verified: true }
+  };
+}
+export {
+  describeDatabase,
+  runInitSequence
+};

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "agent-standup",
+  "version": "0.20.0",
+  "private": false,
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "standup": "dist/bin/standup.js",
+    "standup-hook": "dist/bin/standup-hook.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "prepare": "node scripts/install-git-hooks.mjs",
+    "prepack": "npm run build:cli",
+    "dev": "next dev",
+    "build": "next build",
+    "build:cli": "node scripts/build-cli.mjs",
+    "build:plugin": "node scripts/build-plugin.mjs",
+    "start": "next start",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "node scripts/run-tests.mjs",
+    "test:watch": "vitest",
+    "check:external-refs": "node scripts/check-external-refs.mjs",
+    "generate:http-routes": "node scripts/generate-http-routes.mjs",
+    "check:http-routes": "node scripts/generate-http-routes.mjs --check",
+    "check:db-imports": "node scripts/check-db-import-allowlist.mjs",
+    "check:updater-side-effects": "node scripts/check-updater-side-effects.mjs",
+    "check:event-emitters": "node scripts/check-event-emitters.mjs",
+    "check:hook-freshness": "node scripts/check-hook-freshness.mjs",
+    "check:db-gated": "node scripts/check-db-gated-suites.mjs",
+    "check:db-gated:require": "node scripts/check-db-gated-suites.mjs --require-db",
+    "version:from-tag": "node scripts/version-from-tag.mjs",
+    "db:up": "node scripts/db-up.mjs",
+    "db:migrate": "prisma migrate dev",
+    "db:deploy": "prisma migrate deploy",
+    "db:studio": "prisma studio",
+    "db:check-drift": "node scripts/check-migration-drift.mjs",
+    "db:seed": "node prisma/seed.mjs",
+    "backfill": "node scripts/backfill.mjs",
+    "test:raw": "vitest run"
+  },
+  "dependencies": {
+    "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/modifiers": "^9.0.0",
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "@prisma/client": "^6.0.0",
+    "@radix-ui/react-slot": "^1.3.3",
+    "@tailwindcss/postcss": "^4.3.3",
+    "clsx": "^2.1.1",
+    "geist": "^1.7.2",
+    "lucide-react": "^1.32.0",
+    "next": "^16.0.0",
+    "prisma": "^6.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-markdown": "^10.1.0",
+    "remark-gfm": "^4.0.1",
+    "tailwind-merge": "^3.6.0",
+    "tailwindcss": "^4.3.3",
+    "zod": "^3.24.0"
+  },
+  "overrides": {
+    "qs": "^6.15.2",
+    "deepmerge-ts": "^8.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "@types/pg": "^8.21.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "esbuild": "^0.28.2",
+    "eslint": "^9.0.0",
+    "eslint-config-next": "^16.0.0",
+    "jsdom": "^26.1.0",
+    "pg": "^8.23.0",
+    "prettier": "^3.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.0"
+  }
+}