@stndrds/cli 1.0.0-alpha.258 → 1.0.0-alpha.260

package/dist/bin.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/program.ts
-import chalk7 from "chalk";
+import chalk9 from "chalk";
 import { Command } from "commander";
 
 // src/client.ts
@@ -60,6 +60,29 @@ function createClient(config) {
       body: options?.body ? JSON.stringify(options.body) : void 0
     });
   }
+  async function getText(path, params) {
+    const url = buildUrl(apiUrl, path, params);
+    let response;
+    try {
+      response = await fetch(url, { method: "GET", headers, signal: AbortSignal.timeout(3e4) });
+    } catch (error) {
+      if (error instanceof TypeError || error instanceof DOMException && error.name === "TimeoutError") {
+        throw new ApiClientError(0, `Could not connect to ${apiUrl}. Is the server running?`);
+      }
+      throw error;
+    }
+    const text = await response.text();
+    if (!response.ok) {
+      let message = `Request failed with status ${response.status}`;
+      try {
+        message = JSON.parse(text).message ?? message;
+      } catch {
+        if (text) message = text;
+      }
+      throw new ApiClientError(response.status, message);
+    }
+    return text;
+  }
   function postMultipart(path, form) {
     const url = buildUrl(apiUrl, path);
     const { "Content-Type": _ct, ...multipartHeaders } = headers;
@@ -81,6 +104,7 @@ function createClient(config) {
     delete(path) {
       return request("DELETE", path);
     },
+    getText,
     postMultipart
   };
 }
@@ -105,6 +129,9 @@ function getClientFromCommand(cmd) {
   }
   return createClient({ apiUrl: root.apiUrl, apiKey: root.apiKey, tenantId: root.tenant });
 }
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 
 // src/commands/auth.ts
 function registerAuthCommand(program) {
@@ -278,6 +305,354 @@ function registerConnectorsCommand(program) {
   });
 }
 
+// src/commands/diff.ts
+import chalk4 from "chalk";
+
+// src/drift/engine.ts
+import { createHash } from "crypto";
+import { ValidationError, canonicalStringify, viewSyncPayload } from "@stndrds/schema";
+var SUPPORTED_HASH_VERSION = 1;
+var CONFIG_SUBKEYS = ["tabs", "defaultFilters", "sidePanel"];
+function viewSyncHashOf(view) {
+  return createHash("sha256").update(canonicalStringify(viewSyncPayload(view))).digest("hex");
+}
+function viewKey(object, name, type) {
+  return `${object}:${name}:${type}`;
+}
+function classifyViewDrift(input2) {
+  const { codeHash, dbHash, baselineHash, resolutions } = input2;
+  if (baselineHash === null) {
+    return codeHash === dbHash ? "in-sync" : "runtime-diverged";
+  }
+  const codeMoved = codeHash !== baselineHash;
+  const dbMoved = dbHash !== baselineHash;
+  if (!(codeMoved || dbMoved)) {
+    return "in-sync";
+  }
+  if (codeMoved && !dbMoved) {
+    return "code-changed";
+  }
+  if (!codeMoved && dbMoved) {
+    return "runtime-diverged";
+  }
+  const hasExactResolution = resolutions.some(
+    (resolution) => resolution.codeHash === codeHash && resolution.dbHash === dbHash
+  );
+  return hasExactResolution ? "conflict-resolved" : "conflict";
+}
+function computeChangedFields(localView, entry) {
+  const changedFields = [];
+  if (canonicalStringify(localView.label) !== canonicalStringify(entry.label)) {
+    changedFields.push("label");
+  }
+  if ((localView.description ?? null) !== entry.description) {
+    changedFields.push("description");
+  }
+  if ((localView.icon ?? null) !== entry.icon) {
+    changedFields.push("icon");
+  }
+  if ((localView.default ?? false) !== entry.default) {
+    changedFields.push("default");
+  }
+  if (canonicalStringify(localView.metadata ?? null) !== canonicalStringify(entry.metadata)) {
+    changedFields.push("metadata");
+  }
+  const localConfig = localView.config;
+  const dbConfig = entry.config;
+  for (const key of CONFIG_SUBKEYS) {
+    const localValue = localConfig[key] ?? null;
+    const dbValue = dbConfig[key] ?? null;
+    if (canonicalStringify(localValue) !== canonicalStringify(dbValue)) {
+      changedFields.push(`config.${key}`);
+    }
+  }
+  return changedFields;
+}
+function computeDriftReport(local, state) {
+  if (state.hashVersion !== SUPPORTED_HASH_VERSION) {
+    throw new ValidationError(
+      `Server hash version ${state.hashVersion} is not supported by this CLI (expected ${SUPPORTED_HASH_VERSION}). Upgrade the CLI or the server so both sides compute comparable hashes.`,
+      []
+    );
+  }
+  const stateByKey = /* @__PURE__ */ new Map();
+  for (const entry of state.views) {
+    stateByKey.set(viewKey(entry.object, entry.name, entry.type), entry);
+  }
+  const localKeys = /* @__PURE__ */ new Set();
+  const views = [];
+  const created = [];
+  for (const localView of local.views) {
+    const key = viewKey(localView.object, localView.name, localView.type);
+    localKeys.add(key);
+    const entry = stateByKey.get(key);
+    if (!entry) {
+      created.push({ key, object: localView.object, name: localView.name, type: localView.type });
+      continue;
+    }
+    const codeHash = viewSyncHashOf(localView);
+    const driftState = classifyViewDrift({
+      codeHash,
+      dbHash: entry.dbHash,
+      baselineHash: entry.baselineHash,
+      resolutions: entry.resolutions
+    });
+    views.push({
+      key,
+      type: localView.type,
+      state: driftState,
+      viewId: entry.viewId,
+      codeHash,
+      dbHash: entry.dbHash,
+      changedFields: computeChangedFields(localView, entry)
+    });
+  }
+  const orphans = state.views.filter((entry) => !localKeys.has(viewKey(entry.object, entry.name, entry.type))).map((entry) => ({
+    key: viewKey(entry.object, entry.name, entry.type),
+    viewId: entry.viewId,
+    object: entry.object,
+    name: entry.name,
+    type: entry.type
+  }));
+  const hasUnresolvedConflict = views.some((view) => view.state === "conflict");
+  const exitCode = hasUnresolvedConflict || state.drift.hasUnexpectedDrift ? 1 : 0;
+  return { views, created, orphans, schema: state.drift, exitCode };
+}
+
+// src/schema-loader.ts
+import { dirname, resolve } from "path";
+import { ValidationError as ValidationError2 } from "@stndrds/schema";
+import * as esbuild from "esbuild";
+async function loadLocalRegistry(entryPath) {
+  const absoluteEntryPath = resolve(entryPath);
+  const virtualEntry = [
+    `import ${JSON.stringify(absoluteEntryPath)};`,
+    `export { registry, viewRegistry } from "@stndrds/schema";`
+  ].join("\n");
+  let bundledCode;
+  try {
+    const result = await esbuild.build({
+      stdin: {
+        contents: virtualEntry,
+        resolveDir: dirname(absoluteEntryPath),
+        loader: "ts",
+        sourcefile: "standards-diff-virtual-entry.ts"
+      },
+      bundle: true,
+      platform: "node",
+      format: "esm",
+      write: false,
+      external: ["node:*"],
+      logLevel: "silent"
+    });
+    const outputFile = result.outputFiles[0];
+    if (!outputFile) {
+      throw entryLoadError(absoluteEntryPath, new Error("esbuild produced no output"));
+    }
+    bundledCode = outputFile.text;
+  } catch (error) {
+    throw entryLoadError(absoluteEntryPath, error);
+  }
+  let loadedModule;
+  try {
+    const dataUrl = `data:text/javascript;base64,${Buffer.from(bundledCode, "utf-8").toString("base64")}`;
+    loadedModule = await import(dataUrl);
+  } catch (error) {
+    throw entryLoadError(absoluteEntryPath, error);
+  }
+  return {
+    objects: loadedModule.registry.getAll(),
+    views: loadedModule.viewRegistry.getAll()
+  };
+}
+function entryLoadError(entryPath, cause) {
+  if (cause instanceof ValidationError2) {
+    return cause;
+  }
+  const causeMessage = cause instanceof Error ? cause.message : String(cause);
+  return new ValidationError2(
+    `Schema entry failed to load in isolation: ${entryPath}
+${causeMessage}`,
+    []
+  );
+}
+
+// src/standards-config.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+import { ValidationError as ValidationError3 } from "@stndrds/schema";
+
+// src/standards-dir.ts
+import { existsSync } from "fs";
+import { join } from "path";
+function resolveStandardsDir(startDir = process.cwd()) {
+  let dir = startDir;
+  while (true) {
+    if (existsSync(join(dir, "package.json"))) {
+      return join(dir, ".standards");
+    }
+    const parent = join(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return join(startDir, ".standards");
+}
+
+// src/standards-config.ts
+function readStandardsProjectConfig(startDir = process.cwd()) {
+  const standardsDir = resolveStandardsDir(startDir);
+  const projectRoot = dirname2(standardsDir);
+  const configPath = join2(standardsDir, "config.json");
+  if (!existsSync2(configPath)) {
+    throw new ValidationError3(
+      `No Standards project config found at ${configPath}. Run "standards init" to create one.`,
+      []
+    );
+  }
+  const raw = readFileSync(configPath, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    const causeMessage = error instanceof Error ? error.message : String(error);
+    throw new ValidationError3(`${configPath} is not valid JSON: ${causeMessage}`, []);
+  }
+  if (typeof parsed.schemaEntry !== "string" || parsed.schemaEntry.length === 0) {
+    throw new ValidationError3(
+      `${configPath} is missing required "schemaEntry" field. Run "standards init" to (re)create it.`,
+      []
+    );
+  }
+  return {
+    schemaEntry: resolve2(projectRoot, parsed.schemaEntry)
+  };
+}
+
+// src/commands/diff.ts
+async function runDiffCommand(deps) {
+  const loadRegistry = deps.loadRegistry ?? loadLocalRegistry;
+  let local;
+  let state;
+  try {
+    local = await loadRegistry(deps.schemaEntry);
+    state = await deps.client.get("/schema/state");
+  } catch (error) {
+    return { exitCode: 2, errorMessage: messageOf(error) };
+  }
+  try {
+    const report = computeDriftReport(local, state);
+    return { exitCode: report.exitCode, report, state };
+  } catch (error) {
+    return { exitCode: 2, errorMessage: messageOf(error) };
+  }
+}
+function renderCreatedLine(view) {
+  return chalk4.dim(`+ view ${view.key} \u2014 will be created`);
+}
+function renderOrphanLine(view) {
+  return chalk4.dim(`\u25CB view ${view.key} \u2014 removed from code, still in DB`);
+}
+function renderViewLine(entry) {
+  const fields = entry.changedFields.join(", ");
+  if (entry.state === "code-changed") {
+    return chalk4.green(`~ view ${entry.key} \u2014 will apply on next deploy (code changed: ${fields})`);
+  }
+  if (entry.state === "runtime-diverged") {
+    return chalk4.yellow(
+      `\u2260 view ${entry.key} \u2014 runtime divergence (users changed: ${fields}) \u2014 promote or leave`
+    );
+  }
+  if (entry.state === "conflict") {
+    return chalk4.red(
+      `\u26A0 CONFLICT view ${entry.key} \u2014 next deploy WOULD DESTROY runtime changes (${fields}) \u2014 run "standards pull"`
+    );
+  }
+  return chalk4.green(`\u2713 resolved conflict view ${entry.key} \u2014 code will apply on next deploy`);
+}
+function relationTag(attr) {
+  return attr.isRelation ? " [relation]" : "";
+}
+function attrInline(attr) {
+  const suffix = attr.tolerated ? ", tolerated" : `${relationTag(attr)}, label: "${attr.label}"`;
+  return `   \xB7 ${attr.name} (${attr.type}${suffix})`;
+}
+function renderSchemaDriftLines(schema) {
+  const lines = [];
+  for (const obj of schema.customObjects) {
+    lines.push(chalk4.yellow(`\u26A0  ${obj.name} (${obj.label}) \u2014 custom object, not in code`));
+    lines.push(chalk4.dim('   \u2192 Run "standards pull" to promote or leave.'));
+  }
+  for (const entry of schema.systemObjectDrift) {
+    const unexpected = entry.sealed ? entry.customAttributes.filter((a) => !a.tolerated) : [];
+    const tolerated = entry.customAttributes.filter((a) => a.tolerated);
+    if (entry.sealed && unexpected.length > 0) {
+      lines.push(
+        chalk4.red(
+          `\u2717  ${entry.objectName} \u2014 ${unexpected.length} unexpected custom attribute(s) (sealed object)`
+        )
+      );
+      for (const a of unexpected) lines.push(chalk4.red(attrInline(a)));
+      lines.push(chalk4.dim('   \u2192 Run "standards pull" to promote or tolerate these attributes.'));
+      if (tolerated.length > 0) {
+        lines.push(chalk4.dim(`   Also tolerated: ${tolerated.length} attribute(s)`));
+        for (const a of tolerated) lines.push(chalk4.dim(attrInline(a)));
+      }
+      continue;
+    }
+    const okAttrs = entry.sealed ? tolerated : entry.customAttributes;
+    if (okAttrs.length === 0) continue;
+    const okSuffix = entry.sealed ? "tolerated custom attribute(s) (sealed)" : "custom attribute(s) (extensible)";
+    lines.push(chalk4.green(`\u2713  ${entry.objectName} \u2014 ${okAttrs.length} ${okSuffix}`));
+    for (const a of okAttrs) lines.push(chalk4.dim(attrInline(a)));
+  }
+  return lines;
+}
+function renderDiffLines(report) {
+  const lines = [];
+  for (const view of report.created) lines.push(renderCreatedLine(view));
+  for (const view of report.views) {
+    if (view.state === "in-sync") continue;
+    lines.push(renderViewLine(view));
+  }
+  for (const view of report.orphans) lines.push(renderOrphanLine(view));
+  lines.push(...renderSchemaDriftLines(report.schema));
+  return lines;
+}
+function formatDiffReport(report, format) {
+  if (format === "json") {
+    return JSON.stringify(report, null, 2);
+  }
+  const lines = renderDiffLines(report);
+  return lines.length > 0 ? lines.join("\n") : chalk4.green("\u2713 No drift detected \u2014 next deploy is a no-op.");
+}
+function resolveEffectiveFormat(cmd) {
+  const format = getFormat(cmd);
+  const formatExplicit = cmd.getOptionValueSourceWithGlobals("format") !== "default";
+  return format === "json" && !formatExplicit ? "table" : format;
+}
+function registerDiffCommand(program) {
+  program.command("diff").description("Show what the next deploy will do to the runtime schema and views").action(async (_opts, cmd) => {
+    let client;
+    let schemaEntry;
+    try {
+      client = getClientFromCommand(cmd);
+      schemaEntry = readStandardsProjectConfig().schemaEntry;
+    } catch (error) {
+      console.error(chalk4.red(`\u2717 ${messageOf(error)}`));
+      process.exit(2);
+      return;
+    }
+    const result = await runDiffCommand({ client, schemaEntry });
+    if (result.exitCode === 2) {
+      console.error(chalk4.red(`\u2717 ${result.errorMessage}`));
+      process.exit(2);
+      return;
+    }
+    console.info(formatDiffReport(result.report, resolveEffectiveFormat(cmd)));
+    process.exit(result.exitCode);
+  });
+}
+
 // src/commands/documents.ts
 var BYTE_UNITS = ["B", "KB", "MB", "GB", "TB"];
 function formatFileSize(bytes) {
@@ -353,6 +728,12 @@ function registerDocumentsCommand(program) {
     const client = getClientFromCommand(cmd);
     await client.delete(`/documents/${id}/files/${fileId}`);
     process.stdout.write(`File ${fileId} removed.
+`);
+  });
+  documents.command("content").description("Print a document's aggregated OCR text (every pack file, position order)").argument("<id>", "document ID").action(async (id, _opts, cmd) => {
+    const client = getClientFromCommand(cmd);
+    const text = await client.getText(`/documents/${id}/content`);
+    process.stdout.write(text.endsWith("\n") ? text : `${text}
 `);
   });
 }
@@ -389,8 +770,101 @@ function registerFoldersCommand(program) {
   });
 }
 
+// src/commands/init.ts
+import { copyFileSync, existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { dirname as dirname3, join as join3, relative, resolve as resolve3 } from "path";
+import { fileURLToPath } from "url";
+import { ValidationError as ValidationError4 } from "@stndrds/schema";
+import chalk5 from "chalk";
+var PROMOTIONS_GITIGNORE_LINE = ".standards/promotions/";
+function resolveAssetPath(filename) {
+  const moduleDir = dirname3(fileURLToPath(import.meta.url));
+  const candidates = [
+    join3(moduleDir, "..", "assets", filename),
+    join3(moduleDir, "assets", filename)
+  ];
+  const found = candidates.find((candidate) => existsSync3(candidate));
+  if (!found) {
+    throw new ValidationError4(
+      `Could not locate bundled asset "${filename}" (checked: ${candidates.join(", ")}). This is a packaging bug in @stndrds/cli.`,
+      []
+    );
+  }
+  return found;
+}
+async function runInitCommand(options, deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  await loadLocalRegistry(options.entry);
+  const standardsDir = resolveStandardsDir(cwd);
+  const projectRoot = dirname3(standardsDir);
+  const entryAbsolute = resolve3(cwd, options.entry);
+  const schemaEntry = relative(projectRoot, entryAbsolute);
+  mkdirSync(standardsDir, { recursive: true });
+  const configPath = join3(standardsDir, "config.json");
+  writeFileSync(configPath, `${JSON.stringify({ schemaEntry }, null, 2)}
+`, "utf-8");
+  const gitignorePath = join3(projectRoot, ".gitignore");
+  const gitignore = updateGitignore(gitignorePath);
+  const skillDir = join3(projectRoot, ".claude", "skills", "standards-pull");
+  mkdirSync(skillDir, { recursive: true });
+  const skillPath = join3(skillDir, "SKILL.md");
+  copyFileSync(resolveAssetPath("standards-pull-skill.md"), skillPath);
+  let workflowPath;
+  if (options.ci) {
+    const workflowDir = join3(projectRoot, ".github", "workflows");
+    mkdirSync(workflowDir, { recursive: true });
+    workflowPath = join3(workflowDir, "standards-drift.yml");
+    copyFileSync(resolveAssetPath("standards-drift.yml"), workflowPath);
+  }
+  return { standardsDir, configPath, skillPath, gitignore, workflowPath };
+}
+function updateGitignore(gitignorePath) {
+  if (!existsSync3(gitignorePath)) {
+    return "not-found";
+  }
+  const content = readFileSync2(gitignorePath, "utf-8");
+  const alreadyPresent = content.split("\n").some((line) => line.trim() === PROMOTIONS_GITIGNORE_LINE);
+  if (alreadyPresent) {
+    return "already-present";
+  }
+  const withTrailingNewline = content.length === 0 || content.endsWith("\n") ? content : `${content}
+`;
+  writeFileSync(gitignorePath, `${withTrailingNewline}${PROMOTIONS_GITIGNORE_LINE}
+`, "utf-8");
+  return "updated";
+}
+function registerInitCommand(program) {
+  program.command("init").description(
+    "Bootstrap this project: .standards/config.json, the standards-pull skill, and (optionally) a CI drift check. Re-running restores the managed skill/workflow assets verbatim (overwriting local edits to them); .gitignore is the only step that's merge-safe."
+  ).requiredOption("--entry <path>", "Path to the schema entry file (e.g. src/schema/index.ts)").option("--ci", "Also write .github/workflows/standards-drift.yml").action(async (opts) => {
+    let result;
+    try {
+      result = await runInitCommand({ entry: opts.entry, ci: opts.ci });
+    } catch (error) {
+      console.error(chalk5.red(`\u2717 ${messageOf(error)}`));
+      process.exit(2);
+      return;
+    }
+    console.info(chalk5.green(`\u2713 Wrote ${result.configPath}`));
+    console.info(chalk5.green(`\u2713 Installed skill at ${result.skillPath}`));
+    if (result.gitignore === "updated") {
+      console.info(chalk5.green(`\u2713 Added "${PROMOTIONS_GITIGNORE_LINE}" to .gitignore`));
+    } else if (result.gitignore === "not-found") {
+      console.info(
+        chalk5.dim(
+          `  No .gitignore found \u2014 remember to ignore "${PROMOTIONS_GITIGNORE_LINE}" yourself.`
+        )
+      );
+    }
+    if (result.workflowPath) {
+      console.info(chalk5.green(`\u2713 Wrote ${result.workflowPath}`));
+    }
+    console.info(chalk5.dim('Run "standards diff" to check for drift.'));
+  });
+}
+
 // src/commands/keys.ts
-import chalk4 from "chalk";
+import chalk6 from "chalk";
 function registerKeysCommand(program) {
   const keys = program.command("keys").description("Manage Standards API keys");
   keys.command("list").description("List API keys").action(async (_opts, cmd) => {
@@ -417,11 +891,270 @@ function registerKeysCommand(program) {
     }
     const client = getClientFromCommand(cmd);
     await client.delete(`/api-keys/${id}`);
-    process.stdout.write(`${chalk4.green("\u2713")} API key ${id} revoked.
+    process.stdout.write(`${chalk6.green("\u2713")} API key ${id} revoked.
 `);
   });
 }
 
+// src/commands/pull.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname4, join as join4 } from "path";
+import * as prompts from "@clack/prompts";
+import chalk7 from "chalk";
+function handlePromote(entry, ctx) {
+  const viewState = ctx.viewStateByKey.get(entry.key);
+  if (!viewState) {
+    return {
+      ok: false,
+      message: `No runtime state found for view "${entry.key}" \u2014 cannot promote. The pull context must be built from the same schema state as the drift report.`
+    };
+  }
+  try {
+    const runtimeConfig = {
+      object: viewState.object,
+      name: viewState.name,
+      type: viewState.type,
+      label: viewState.label,
+      description: viewState.description,
+      icon: viewState.icon,
+      default: viewState.default,
+      metadata: viewState.metadata,
+      config: viewState.config
+    };
+    const builderHint = findBuilderFileHint(
+      ctx.schemaEntry,
+      viewState.object,
+      viewState.name,
+      viewState.type
+    );
+    const promotionsDir = join4(ctx.standardsDir, "promotions");
+    mkdirSync2(promotionsDir, { recursive: true });
+    const filePath = join4(
+      promotionsDir,
+      `${viewState.object}-${viewState.name}-${viewState.type}.md`
+    );
+    const content = [
+      `# Promote view \`${entry.key}\``,
+      "",
+      "Runtime users changed this view since it was last synced from code. To keep",
+      "their changes, fold this configuration into the view's builder call below.",
+      "",
+      "## Runtime config",
+      "",
+      "```json",
+      JSON.stringify(runtimeConfig, null, 2),
+      "```",
+      "",
+      "## Builder file",
+      "",
+      builderHint,
+      "",
+      "---",
+      "",
+      "Hand this file to your agent, then re-run `standards diff`.",
+      ""
+    ].join("\n");
+    writeFileSync2(filePath, content, "utf-8");
+    return { ok: true, filePath };
+  } catch (error) {
+    return {
+      ok: false,
+      message: `Failed to write promotion file for ${entry.key}: ${messageOf(error)}`
+    };
+  }
+}
+async function handleOverwrite(entry, _ctx, client) {
+  try {
+    await client.post("/schema/resolutions", {
+      viewId: entry.viewId,
+      codeHash: entry.codeHash,
+      dbHash: entry.dbHash
+    });
+    return { ok: true };
+  } catch (error) {
+    if (error instanceof ApiClientError && error.statusCode === 400) {
+      return {
+        ok: false,
+        reason: "stale",
+        message: `View ${entry.key} changed since the diff \u2014 re-run "standards diff".`
+      };
+    }
+    return {
+      ok: false,
+      reason: "infra",
+      message: `Failed to overwrite ${entry.key}: ${messageOf(error)}`
+    };
+  }
+}
+var BUILDER_SOURCE_EXTENSIONS = [".ts", ".tsx"];
+var BUILDER_SEARCH_IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", ".git"]);
+function collectSourceFiles(dir) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    if (BUILDER_SEARCH_IGNORED_DIRS.has(entry.name)) continue;
+    const fullPath = join4(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectSourceFiles(fullPath));
+    } else if (BUILDER_SOURCE_EXTENSIONS.some((ext) => entry.name.endsWith(ext))) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function findBuilderFileHint(schemaEntry, object, name, type) {
+  const builderCall = type === "detail" ? "detailView" : "listView";
+  const pattern = new RegExp(`${builderCall}\\(\\s*["'\`]${escapeRegExp(name)}["'\`]`);
+  const searchDir = dirname4(schemaEntry);
+  for (const filePath of collectSourceFiles(searchDir)) {
+    const lines = readFileSync3(filePath, "utf-8").split("\n");
+    const lineIndex = lines.findIndex((line) => pattern.test(line));
+    if (lineIndex !== -1) {
+      return `\`${filePath}:${lineIndex + 1}\`
+
+\`\`\`ts
+${lines[lineIndex]?.trim()}
+\`\`\``;
+    }
+  }
+  return `No \`${builderCall}("${name}", ...)\` call found under ${searchDir} \u2014 search manually for the "${object}" object's view builders.`;
+}
+function entriesNeedingDecisionOf(result) {
+  if (result.exitCode === 2) return [];
+  const conflicts = result.report.views.filter((view) => view.state === "conflict");
+  const diverged = result.report.views.filter((view) => view.state === "runtime-diverged");
+  return [...conflicts, ...diverged];
+}
+async function runPullCommand(deps, decide) {
+  const initial = await runDiffCommand(deps);
+  if (initial.exitCode === 2) {
+    return { initial, outcomes: [], residual: initial };
+  }
+  const entriesNeedingDecision = entriesNeedingDecisionOf(initial);
+  const viewStateByKey = new Map(
+    initial.state.views.map((entry) => [viewKey(entry.object, entry.name, entry.type), entry])
+  );
+  const ctx = {
+    viewStateByKey,
+    schemaEntry: deps.schemaEntry,
+    standardsDir: deps.standardsDir
+  };
+  const outcomes = [];
+  for (const entry of entriesNeedingDecision) {
+    const decision = await decide(entry);
+    if (decision === "promote") {
+      const promote = handlePromote(entry, ctx);
+      outcomes.push({ entry, decision, promote });
+      if (!promote.ok) {
+        return { initial, outcomes, residual: { exitCode: 2, errorMessage: promote.message } };
+      }
+      continue;
+    }
+    if (decision === "overwrite") {
+      const overwrite = await handleOverwrite(entry, ctx, deps.client);
+      outcomes.push({ entry, decision, overwrite });
+      if (!overwrite.ok && overwrite.reason === "infra") {
+        return { initial, outcomes, residual: { exitCode: 2, errorMessage: overwrite.message } };
+      }
+      continue;
+    }
+    outcomes.push({ entry, decision: "skip" });
+  }
+  const residual = await runDiffCommand(deps);
+  return { initial, outcomes, residual };
+}
+function decisionOptionsFor(entry) {
+  const options = [
+    {
+      value: "promote",
+      label: "Promote",
+      hint: "write the runtime config to .standards/promotions/"
+    }
+  ];
+  if (entry.state === "conflict") {
+    options.push({
+      value: "overwrite",
+      label: "Overwrite",
+      hint: "accept the code version, discard the runtime change"
+    });
+  }
+  options.push({ value: "skip", label: "Skip", hint: "leave this view as-is for now" });
+  return options;
+}
+async function promptDecision(entry) {
+  const label = entry.state === "conflict" ? "CONFLICT" : "runtime divergence";
+  const answer = await prompts.select({
+    message: `${entry.key} \u2014 ${label} (${entry.changedFields.join(", ")})`,
+    options: decisionOptionsFor(entry)
+  });
+  if (prompts.isCancel(answer)) {
+    return "skip";
+  }
+  return answer;
+}
+function registerPullCommand(program) {
+  program.command("pull").description("Interactively resolve view drift: promote runtime changes or overwrite them").action(async (_opts, cmd) => {
+    let client;
+    let schemaEntry;
+    let standardsDir;
+    try {
+      client = getClientFromCommand(cmd);
+      schemaEntry = readStandardsProjectConfig().schemaEntry;
+      standardsDir = resolveStandardsDir();
+    } catch (error) {
+      console.error(chalk7.red(`\u2717 ${messageOf(error)}`));
+      process.exit(2);
+      return;
+    }
+    let result;
+    try {
+      result = await runPullCommand({ client, schemaEntry, standardsDir }, promptDecision);
+    } catch (error) {
+      console.error(chalk7.red(`\u2717 ${messageOf(error)}`));
+      process.exit(2);
+      return;
+    }
+    if (result.initial.exitCode === 2) {
+      console.error(chalk7.red(`\u2717 ${result.initial.errorMessage}`));
+      process.exit(2);
+      return;
+    }
+    if (result.outcomes.length === 0) {
+      console.info(chalk7.dim("No conflicts or runtime-diverged views need a decision."));
+    }
+    for (const outcome of result.outcomes) {
+      if (outcome.decision === "promote") {
+        if (outcome.promote.ok) {
+          console.info(chalk7.green(`\u2713 Wrote ${outcome.promote.filePath}`));
+        } else {
+          console.error(chalk7.red(`\u2717 ${outcome.promote.message}`));
+        }
+      } else if (outcome.decision === "overwrite") {
+        if (outcome.overwrite.ok) {
+          console.info(chalk7.green(`\u2713 Overwrote ${outcome.entry.key}`));
+        } else {
+          console.error(chalk7.red(`\u2717 ${outcome.overwrite.message}`));
+        }
+      }
+    }
+    if (result.residual.exitCode === 2) {
+      console.error(chalk7.red(`\u2717 ${result.residual.errorMessage}`));
+      process.exit(2);
+      return;
+    }
+    console.info(formatDiffReport(result.residual.report, resolveEffectiveFormat(cmd)));
+    process.exit(result.residual.exitCode);
+  });
+}
+
 // src/commands/records.ts
 import { readFile as readFile2 } from "fs/promises";
 import { basename } from "path";
@@ -502,20 +1235,20 @@ function registerRecordsCommand(program) {
 // src/commands/root.ts
 import { stdin as input, stdout as output } from "process";
 import { createInterface } from "readline/promises";
-import chalk5 from "chalk";
+import chalk8 from "chalk";
 
 // src/config.ts
 import { mkdir, readFile as readFile3, rm, writeFile } from "fs/promises";
 import { homedir } from "os";
-import { dirname, join } from "path";
+import { dirname as dirname5, join as join5 } from "path";
 var DEFAULT_API_URL = "http://localhost:4100/v1";
 var ENV_PROFILE_NAME = "sandbox";
 function getDefaultApiUrl() {
   return DEFAULT_API_URL;
 }
 function getConfigPath() {
-  const configDir = process.env.STANDARDS_CONFIG_DIR ?? join(homedir(), ".standards");
-  return join(configDir, "config.json");
+  const configDir = process.env.STANDARDS_CONFIG_DIR ?? join5(homedir(), ".standards");
+  return join5(configDir, "config.json");
 }
 async function readConfig() {
   try {
@@ -534,7 +1267,7 @@ async function readConfig() {
 }
 async function writeConfig(config) {
   const path = getConfigPath();
-  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  await mkdir(dirname5(path), { recursive: true, mode: 448 });
   await writeFile(path, `${JSON.stringify(config, null, 2)}
 `, { mode: 384 });
 }
@@ -642,7 +1375,7 @@ function registerRootCommands(program) {
     await client.get("/api-keys");
     await upsertProfile({ name: opts.name, apiUrl: opts.url, apiKey });
     process.stdout.write(
-      `${chalk5.green("\u2713")} Standards instance "${opts.name}" saved and selected.
+      `${chalk8.green("\u2713")} Standards instance "${opts.name}" saved and selected.
 `
     );
     process.stdout.write(`  API URL: ${opts.url}
@@ -654,7 +1387,7 @@ function registerRootCommands(program) {
   });
   program.command("use").description("Select the active Standards instance").argument("<name>", "instance name").action(async (name) => {
     await setCurrentProfile(name);
-    process.stdout.write(`${chalk5.green("\u2713")} Standards instance "${name}" selected.
+    process.stdout.write(`${chalk8.green("\u2713")} Standards instance "${name}" selected.
 `);
   });
   program.command("instances").description("List configured Standards instances").action(async (_opts, cmd) => {
@@ -673,17 +1406,12 @@ function registerRootCommands(program) {
   });
   program.command("logout").description("Remove a Standards instance from local CLI config").argument("[name]", "instance name, defaults to current").action(async (name) => {
     await removeProfile(name);
-    process.stdout.write(`${chalk5.green("\u2713")} Standards instance removed.
+    process.stdout.write(`${chalk8.green("\u2713")} Standards instance removed.
 `);
   });
 }
 
 // src/commands/schema.ts
-import { createHash } from "crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { join as join2 } from "path";
-import { fileURLToPath } from "url";
-import chalk6 from "chalk";
 function registerSchemaCommand(program) {
   const schema = program.command("schema").description("Inspect schema objects and attributes");
   schema.command("list").description("List all schema objects").action(async (_opts, cmd) => {
@@ -696,201 +1424,10 @@ function registerSchemaCommand(program) {
     const result = await client.get(`/schema/objects/${objectName}`);
     formatOutput(result, getFormat(cmd));
   });
-  schema.command("diff").description("Show runtime drift between DB and code schema").option("--object <name>", "Scope to a single object").option("--quiet", "Exit code only, no output").action(async (opts, cmd) => {
-    const format = getFormat(cmd);
-    const result = await fetchDrift(getClientFromCommand(cmd), opts.object);
-    if (format === "json" && cmd.getOptionValueSourceWithGlobals("format") !== "default") {
-      formatOutput(result, "json");
-    } else if (!opts.quiet) {
-      printDiffOutput(result);
-    }
-    process.exit(result.hasUnexpectedDrift ? 1 : 0);
-  });
-  schema.command("pull").description("Generate an AI-ready prompt to resolve schema drift").option("--object <name>", "Scope to a single object").option("--no-save", "Print to stdout only, do not write to .standards/").option("--output <file>", "Write prompt to a specific file path").action(async (opts, cmd) => {
-    const result = await fetchDrift(getClientFromCommand(cmd), opts.object);
-    const totalDrift = result.summary.totalCustomObjects + result.summary.totalCustomAttributes;
-    if (totalDrift === 0) {
-      console.info(chalk6.green("\u2713 No drift detected \u2014 nothing to pull."));
-      process.exit(0);
-    }
-    const globalOpts = cmd.optsWithGlobals();
-    const prompt = buildPullPrompt(result, globalOpts.apiUrl ?? "unknown");
-    const shouldSave = opts.save !== false;
-    if (opts.output) {
-      writeFileSync(opts.output, prompt, "utf-8");
-      console.info(chalk6.green(`\u2713 Prompt written to ${opts.output}`));
-      return;
-    }
-    if (shouldSave) {
-      const standardsDir = resolveStandardsDir();
-      const pullsDir = join2(standardsDir, "pulls");
-      const diffDir = join2(standardsDir, "diff");
-      mkdirSync(pullsDir, { recursive: true });
-      mkdirSync(diffDir, { recursive: true });
-      const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      const hash = createHash("sha1").update(JSON.stringify(result)).digest("hex").slice(0, 6);
-      const filename = join2(pullsDir, `${date}-${hash}.md`);
-      writeFileSync(filename, prompt, "utf-8");
-      writeFileSync(join2(diffDir, "latest.json"), JSON.stringify(result, null, 2), "utf-8");
-      console.info(chalk6.green(`\u2713 Pull prompt written to ${filename}`));
-      console.info(chalk6.dim("  Copy-paste its contents into your LLM to resolve the drift."));
-    } else {
-      process.stdout.write(prompt);
-    }
-  });
-}
-var fetchDrift = (client, object) => client.get("/schema/drift", object ? { object } : {});
-var relationTag = (attr) => attr.isRelation ? " [relation]" : "";
-var attrInline = (attr) => {
-  const suffix = attr.tolerated ? ", tolerated" : `${relationTag(attr)}, label: "${attr.label}"`;
-  return `   \xB7 ${attr.name} (${attr.type}${suffix})`;
-};
-function printDiffOutput(result) {
-  const lines = [];
-  for (const obj of result.customObjects) {
-    lines.push(chalk6.yellow(`\u26A0  ${obj.name} (${obj.label}) \u2014 custom object, not in code`));
-    lines.push(chalk6.dim('   \u2192 Run "standards pull" to promote or leave.'));
-  }
-  for (const entry of result.systemObjectDrift) {
-    const unexpected = entry.sealed ? entry.customAttributes.filter((a) => !a.tolerated) : [];
-    const tolerated = entry.customAttributes.filter((a) => a.tolerated);
-    if (entry.sealed && unexpected.length > 0) {
-      lines.push(
-        chalk6.red(
-          `\u2717  ${entry.objectName} \u2014 ${unexpected.length} unexpected custom attribute(s) (sealed object)`
-        )
-      );
-      for (const attr of unexpected) lines.push(chalk6.red(attrInline(attr)));
-      lines.push(chalk6.dim('   \u2192 Run "standards pull" to promote or tolerate these attributes.'));
-      if (tolerated.length > 0) {
-        lines.push(chalk6.dim(`   Also tolerated: ${tolerated.length} attribute(s)`));
-        for (const attr of tolerated) lines.push(chalk6.dim(attrInline(attr)));
-      }
-      continue;
-    }
-    const okAttrs = entry.sealed ? tolerated : entry.customAttributes;
-    if (okAttrs.length === 0) continue;
-    const okSuffix = entry.sealed ? "tolerated custom attribute(s) (sealed)" : "custom attribute(s) (extensible)";
-    lines.push(chalk6.green(`\u2713  ${entry.objectName} \u2014 ${okAttrs.length} ${okSuffix}`));
-    for (const attr of okAttrs) lines.push(chalk6.dim(attrInline(attr)));
-  }
-  if (lines.length === 0) {
-    console.info(chalk6.green("\u2713 No drift detected."));
-    return;
-  }
-  console.info(lines.join("\n"));
-  if (result.hasUnexpectedDrift) {
-    console.info(
-      chalk6.red(
-        `
-\u2717 Unexpected drift: ${result.summary.totalUnexpected} attribute(s) on sealed object(s).`
-      )
-    );
-  } else {
-    console.info(chalk6.green("\n\u2713 No unexpected drift."));
-  }
-}
-function resolveStandardsDir() {
-  let dir = process.cwd();
-  while (true) {
-    if (existsSync(join2(dir, "package.json"))) {
-      return join2(dir, ".standards");
-    }
-    const parent = join2(dir, "..");
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return join2(process.cwd(), ".standards");
-}
-function buildPullPrompt(result, instanceUrl) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const builderRef = loadBuilderReference();
-  const formatAttr = (attr) => {
-    const toleratedNote = attr.tolerated ? " *(already tolerated)*" : "";
-    return `  - ${attr.name}${relationTag(attr)}${toleratedNote} \u2014 type: ${attr.type}, label: "${attr.label}"`;
-  };
-  const lines = [
-    "# Standards Schema Pull",
-    "generated-with: standards-cli",
-    `generated-at: ${now}`,
-    `instance: ${instanceUrl}`,
-    "",
-    "---",
-    "",
-    "## Standards Schema Builder \u2014 Reference",
-    "",
-    builderRef,
-    "",
-    "---",
-    "",
-    "## Runtime Drift",
-    "",
-    "The following attributes and objects exist in the database but are not declared",
-    "in the code schema. For each one, the user will decide what to do.",
-    ""
-  ];
-  if (result.customObjects.length > 0) {
-    lines.push("### Custom Objects (not declared in code)");
-    lines.push("");
-    for (const obj of result.customObjects) {
-      lines.push(`**${obj.name}** \u2014 label: "${obj.label}"`);
-      for (const attr of obj.attributes) lines.push(formatAttr(attr));
-      lines.push("");
-    }
-  }
-  if (result.systemObjectDrift.length > 0) {
-    lines.push("### Custom Attributes on Existing Objects");
-    lines.push("");
-    for (const entry of result.systemObjectDrift) {
-      const sealedNote = entry.sealed ? " **(sealed \u2014 CI fails until resolved)**" : " (extensible)";
-      lines.push(`**${entry.objectName}**${sealedNote} \u2014 label: "${entry.objectLabel}"`);
-      for (const attr of entry.customAttributes) lines.push(formatAttr(attr));
-      lines.push("");
-    }
-  }
-  lines.push("---");
-  lines.push("");
-  lines.push("## Your Task");
-  lines.push("");
-  lines.push("1. **Explore the codebase** to find the schema files where each object is declared");
-  lines.push('   (look for `object("name")` calls importing from `@stndrds/schema`)');
-  lines.push("");
-  lines.push("2. **Present each attribute and custom object to the user**, one object at a time.");
-  lines.push("   For each, explain what it is and ask the user to choose:");
-  lines.push(
-    "   - **Promote** \u2192 will add `.attribute(...)` to the object builder (becomes system on next boot)"
-  );
-  lines.push(
-    '   - **Tolerate** \u2192 will add to `.tolerate(["name"])` (required on sealed objects to fix CI)'
-  );
-  lines.push("   - **Leave** \u2192 do nothing (will keep appearing in future `standards diff` runs)");
-  lines.push("");
-  lines.push("3. **Collect all decisions** before writing any code. Once the user has decided");
-  lines.push("   for every attribute, **apply all changes in one pass**.");
-  lines.push("");
-  lines.push("4. **Verify** by running: `standards diff`");
-  lines.push("");
-  lines.push("Refer to the Standards Schema Builder Reference above for the exact API.");
-  lines.push(
-    "For relation attributes, use the `relation()` builder with bilateral config if needed."
-  );
-  return lines.join("\n");
-}
-function loadBuilderReference() {
-  const candidates = [
-    join2(fileURLToPath(new URL(".", import.meta.url)), "../assets/schema-builder-reference.md"),
-    join2(process.cwd(), "packages/cli/src/assets/schema-builder-reference.md")
-  ];
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) {
-      return readFileSync(candidate, "utf-8");
-    }
-  }
-  return "[Standards Schema Builder Reference \u2014 see packages/cli/src/assets/schema-builder-reference.md]";
 }
 
 // src/program.ts
-var PUBLIC_COMMANDS = /* @__PURE__ */ new Set(["login", "use", "instances", "current", "logout", "help"]);
+var PUBLIC_COMMANDS = /* @__PURE__ */ new Set(["login", "use", "instances", "current", "logout", "help", "init"]);
 function isPublicCommand(actionCommand) {
   if (PUBLIC_COMMANDS.has(actionCommand.name())) return true;
   return actionCommand.parent?.name() === "auth" && actionCommand.name() === "help";
@@ -901,6 +1438,9 @@ function createProgram() {
   registerRootCommands(program);
   registerRecordsCommand(program);
   registerSchemaCommand(program);
+  registerDiffCommand(program);
+  registerPullCommand(program);
+  registerInitCommand(program);
   registerDocumentsCommand(program);
   registerFoldersCommand(program);
   registerKeysCommand(program);
@@ -921,11 +1461,11 @@ function createProgram() {
     program.setOptionValue("tenant", raw.tenant);
     if (!(resolved.apiKey || isPublicCommand(actionCommand))) {
       console.error(
-        chalk7.red(
+        chalk9.red(
           `\u2717 Error: No Standards instance configured. Run "standards login" or pass --api-key.`
         )
       );
-      process.exit(1);
+      process.exit(2);
     }
   });
   return program;
@@ -935,12 +1475,12 @@ async function runProgram(argv = process.argv) {
   await program.parseAsync(argv).catch((error) => {
     if (error instanceof ApiClientError) {
       if (error.statusCode > 0) {
-        console.error(chalk7.red(`\u2717 Error (${error.statusCode}): ${error.message}`));
+        console.error(chalk9.red(`\u2717 Error (${error.statusCode}): ${error.message}`));
       } else {
-        console.error(chalk7.red(`\u2717 Error: ${error.message}`));
+        console.error(chalk9.red(`\u2717 Error: ${error.message}`));
       }
     } else if (error instanceof Error) {
-      console.error(chalk7.red(`\u2717 Error: ${error.message}`));
+      console.error(chalk9.red(`\u2717 Error: ${error.message}`));
     }
     process.exit(1);
   });