@lunora/config 1.0.0-alpha.81 → 1.0.0-alpha.83

package/dist/packem_shared/buildPackageSecretsBlock-BxOcyaAY.mjs

@@ -1,281 +0,0 @@
-import { randomBytes } from 'node:crypto';
-import { existsSync, readFileSync, writeFileSync, renameSync, rmSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-import { LunoraError } from '@lunora/errors';
-import { DEV_VARS_FILE, DEV_VARS_EXAMPLE_FILE, splitDevVariableLine, parseDevVariableEntries, DEV_VARS_NEWLINE, unquoteDevVariable } from './DEV_VARS_EXAMPLE_FILE-dJPNTEnK.mjs';
-import { CORE_SECRETS, PACKAGE_SECRETS_REGISTRY, secretsForPackages } from './PACKAGE_SECRETS_REGISTRY-NCTSphDk.mjs';
-
-const requiredSecrets = (packageNames) => [...CORE_SECRETS, ...secretsForPackages(packageNames)];
-const SECRET_BYTES = 32;
-const SECRET_KEY = /(?:KEY|PASSWORD|SECRET|TOKEN)$/u;
-const PLACEHOLDER_MARKERS = [
-  "replace",
-  "openssl",
-  "changeme",
-  "change-me",
-  "change_me",
-  "change-this",
-  "change_this",
-  "your-",
-  "your_",
-  "example",
-  "placeholder",
-  "todo",
-  "fill-me",
-  "fill_me",
-  "fill-in",
-  "fill_in",
-  "xxx"
-];
-const REGEXP_SPECIAL_CHARS = /[.*+?^${}()|[\]\\]/gu;
-const MARKER_ENDS_ALPHANUMERIC = /[a-z0-9]$/u;
-const isPlaceholderValue = (value) => {
-  const normalised = value.trim().toLowerCase();
-  if (normalised === "") {
-    return true;
-  }
-  if (normalised.startsWith("<") && normalised.endsWith(">")) {
-    return true;
-  }
-  return PLACEHOLDER_MARKERS.some((marker) => {
-    const escaped = marker.replaceAll(REGEXP_SPECIAL_CHARS, String.raw`\$&`);
-    const needsTrailingBoundary = MARKER_ENDS_ALPHANUMERIC.test(marker);
-    const pattern = needsTrailingBoundary ? `(^|[^a-z0-9])${escaped}([^a-z0-9]|$)` : `(^|[^a-z0-9])${escaped}`;
-    return new RegExp(pattern, "u").test(normalised);
-  });
-};
-const isPlaceholder = (rawValue) => isPlaceholderValue(unquoteDevVariable(rawValue.trim()));
-const defaultRandomHex = (bytes) => randomBytes(bytes).toString("hex");
-const PROVIDER_SECRET_KEYS = new Set(
-  [...CORE_SECRETS, ...Object.values(PACKAGE_SECRETS_REGISTRY).flat()].filter((entry) => SECRET_KEY.test(entry.key) && entry.placeholderValue.startsWith("<")).map((entry) => entry.key)
-);
-const isMintableSecretKey = (key) => SECRET_KEY.test(key) && !PROVIDER_SECRET_KEYS.has(key);
-const generatedSecretFor = (key, rawValue, randomHex) => isMintableSecretKey(key) && isPlaceholder(rawValue) ? randomHex(SECRET_BYTES) : void 0;
-const generateSecretValue = (randomHex = defaultRandomHex) => randomHex(SECRET_BYTES);
-const planDevVariablesScaffold = (input) => {
-  if (input.devVarsExists) {
-    return { status: "exists" };
-  }
-  if (input.exampleContent === void 0) {
-    return { status: "no-example" };
-  }
-  const randomHex = input.randomHex ?? defaultRandomHex;
-  const generatedKeys = [];
-  const lines = input.exampleContent.split(DEV_VARS_NEWLINE).map((line) => {
-    const parsed = splitDevVariableLine(line);
-    const secret = parsed ? generatedSecretFor(parsed.key, parsed.value, randomHex) : void 0;
-    if (!parsed || secret === void 0) {
-      return line;
-    }
-    generatedKeys.push(parsed.key);
-    return `${parsed.key}="${secret}"`;
-  });
-  return { content: lines.join("\n"), generatedKeys, status: "generate" };
-};
-const planDevVariablesAugment = (input) => {
-  const randomHex = input.randomHex ?? defaultRandomHex;
-  const present = new Set(parseDevVariableEntries(input.existingContent).map((entry) => entry.key));
-  const additions = [];
-  const generatedKeys = [];
-  const missingKeys = [];
-  for (const line of input.exampleContent.split(DEV_VARS_NEWLINE)) {
-    const parsed = splitDevVariableLine(line);
-    if (!parsed || present.has(parsed.key)) {
-      continue;
-    }
-    const secret = generatedSecretFor(parsed.key, parsed.value, randomHex);
-    missingKeys.push(parsed.key);
-    if (secret === void 0) {
-      additions.push(`${parsed.key}="${unquoteDevVariable(parsed.value)}"`);
-    } else {
-      generatedKeys.push(parsed.key);
-      additions.push(`${parsed.key}="${secret}"`);
-    }
-  }
-  return { additions, generatedKeys, missingKeys };
-};
-const generatedSuffix = (keys) => keys.length > 0 ? ` (generated ${keys.join(", ")})` : "";
-const atomicCreateDevVariables = (path, content) => {
-  const temporaryPath = `${path}.tmp-${String(process.pid)}`;
-  try {
-    writeFileSync(temporaryPath, content, { encoding: "utf8", flag: "wx", mode: 384 });
-    renameSync(temporaryPath, path);
-  } catch (error) {
-    rmSync(temporaryPath, { force: true });
-    throw error;
-  }
-};
-const APPEND_MAX_ATTEMPTS = 5;
-const fingerprintOf = (path) => {
-  try {
-    const stats = statSync(path);
-    return { mtimeMs: stats.mtimeMs, size: stats.size };
-  } catch {
-    return void 0;
-  }
-};
-const sameFingerprint = (a, b) => {
-  if (a === void 0 || b === void 0) {
-    return false;
-  }
-  return a.mtimeMs === b.mtimeMs && a.size === b.size;
-};
-const appendDevVariables = (path, buildAdditions) => {
-  for (let attempt = 0; attempt < APPEND_MAX_ATTEMPTS; attempt += 1) {
-    const beforeFingerprint = fingerprintOf(path);
-    const existing = readFileSync(path, "utf8");
-    const additions = buildAdditions(existing);
-    if (additions.length === 0) {
-      return [];
-    }
-    const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
-    const content = `${existing}${separator}${additions.join("\n")}
-`;
-    const temporaryPath = `${path}.tmp-${String(process.pid)}-${randomBytes(6).toString("hex")}`;
-    try {
-      writeFileSync(temporaryPath, content, { encoding: "utf8", mode: 384 });
-      const beforeRenameFingerprint = fingerprintOf(path);
-      if (!sameFingerprint(beforeFingerprint, beforeRenameFingerprint)) {
-        rmSync(temporaryPath, { force: true });
-        continue;
-      }
-      renameSync(temporaryPath, path);
-      return additions;
-    } catch (error) {
-      rmSync(temporaryPath, { force: true });
-      throw error;
-    }
-  }
-  throw new LunoraError("INTERNAL", `Failed to append to ${path} after ${String(APPEND_MAX_ATTEMPTS)} attempts — a concurrent writer kept winning the race.`);
-};
-const ensureDevVariables = async (deps) => {
-  const devVariablesPath = join(deps.cwd, DEV_VARS_FILE);
-  const examplePath = join(deps.cwd, DEV_VARS_EXAMPLE_FILE);
-  if (!existsSync(examplePath)) {
-    return { addedKeys: [], generatedKeys: [], status: "no-example" };
-  }
-  const exampleContent = readFileSync(examplePath, "utf8");
-  if (!existsSync(devVariablesPath)) {
-    const plan = planDevVariablesScaffold({ devVarsExists: false, exampleContent, randomHex: deps.randomHex });
-    if (plan.status !== "generate") {
-      return { addedKeys: [], generatedKeys: [], status: "no-example" };
-    }
-    const proceed2 = deps.yes === true || await deps.confirm(`No ${DEV_VARS_FILE} found. Generate it from ${DEV_VARS_EXAMPLE_FILE} (secrets auto-filled)?`);
-    if (!proceed2) {
-      deps.info(`Skipped — copy ${DEV_VARS_EXAMPLE_FILE} to ${DEV_VARS_FILE} and fill it in when you're ready.`);
-      return { addedKeys: [], generatedKeys: [], status: "declined" };
-    }
-    if (existsSync(devVariablesPath)) {
-      return { addedKeys: [], generatedKeys: [], status: "skipped-exists" };
-    }
-    atomicCreateDevVariables(devVariablesPath, plan.content);
-    deps.info(`Created ${DEV_VARS_FILE}${generatedSuffix(plan.generatedKeys)}.`);
-    return { addedKeys: [], generatedKeys: plan.generatedKeys, status: "generated" };
-  }
-  const augment = planDevVariablesAugment({ existingContent: readFileSync(devVariablesPath, "utf8"), exampleContent, randomHex: deps.randomHex });
-  if (augment.missingKeys.length === 0) {
-    return { addedKeys: [], generatedKeys: [], status: "exists" };
-  }
-  const list = augment.missingKeys.join(", ");
-  const proceed = deps.yes === true || await deps.confirm(`${DEV_VARS_FILE} is missing ${String(augment.missingKeys.length)} key(s) from ${DEV_VARS_EXAMPLE_FILE} (${list}). Add them?`);
-  if (!proceed) {
-    deps.info(`Skipped — add ${list} to ${DEV_VARS_FILE} when you're ready.`);
-    return { addedKeys: [], generatedKeys: [], status: "declined" };
-  }
-  const written = appendDevVariables(
-    devVariablesPath,
-    (currentContent) => planDevVariablesAugment({ existingContent: currentContent, exampleContent, randomHex: deps.randomHex }).additions
-  );
-  const writtenKeys = written.map((line) => splitDevVariableLine(line)?.key).filter((key) => key !== void 0);
-  if (writtenKeys.length === 0) {
-    return { addedKeys: [], generatedKeys: [], status: "exists" };
-  }
-  const writtenGeneratedKeys = augment.generatedKeys.filter((key) => writtenKeys.includes(key));
-  deps.info(`Updated ${DEV_VARS_FILE} — added ${writtenKeys.join(", ")}${generatedSuffix(writtenGeneratedKeys)}.`);
-  return { addedKeys: writtenKeys, generatedKeys: writtenGeneratedKeys, status: "augmented" };
-};
-const secretEntryBlock = (entry) => {
-  const lines = [`# ${entry.description}`, `# Docs: ${entry.docsUrl}`, `${entry.key}="${entry.placeholderValue}"`];
-  return lines.join("\n");
-};
-const buildPackageSecretsBlock = (packageNames, existingKeys) => {
-  const entries = requiredSecrets(packageNames).filter((entry) => !existingKeys.has(entry.key));
-  if (entries.length === 0) {
-    return "";
-  }
-  return entries.map((entry) => secretEntryBlock(entry)).join("\n\n");
-};
-const ensureDevVariablesExample = (cwd, packageNames) => {
-  const examplePath = join(cwd, DEV_VARS_EXAMPLE_FILE);
-  const existing = existsSync(examplePath) ? readFileSync(examplePath, "utf8") : "";
-  const existingKeys = new Set(parseDevVariableEntries(existing).map((entry) => entry.key));
-  const block = buildPackageSecretsBlock(packageNames, existingKeys);
-  if (block === "") {
-    return [];
-  }
-  const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
-  const newContent = `${existing}${separator}
-${block}
-`;
-  const temporaryPath = `${examplePath}.tmp-${String(process.pid)}`;
-  try {
-    writeFileSync(temporaryPath, newContent, { encoding: "utf8" });
-    renameSync(temporaryPath, examplePath);
-  } catch (error) {
-    rmSync(temporaryPath, { force: true });
-    throw error;
-  }
-  return requiredSecrets(packageNames).filter((entry) => !existingKeys.has(entry.key)).map((entry) => entry.key);
-};
-const planDevSecretsFill = (input) => {
-  const randomHex = input.randomHex ?? defaultRandomHex;
-  const filledKeys = [];
-  const lines = input.existingContent.split(DEV_VARS_NEWLINE).map((line) => {
-    const parsed = splitDevVariableLine(line);
-    const secret = parsed ? generatedSecretFor(parsed.key, parsed.value, randomHex) : void 0;
-    if (!parsed || secret === void 0) {
-      return line;
-    }
-    filledKeys.push(parsed.key);
-    return `${parsed.key}="${secret}"`;
-  });
-  const present = new Set(parseDevVariableEntries(input.existingContent).map((entry) => entry.key));
-  const addedKeys = [];
-  const additions = [];
-  for (const entry of CORE_SECRETS) {
-    if (present.has(entry.key)) {
-      continue;
-    }
-    addedKeys.push(entry.key);
-    additions.push(`# ${entry.description}`, `${entry.key}="${randomHex(SECRET_BYTES)}"`);
-  }
-  const body = lines.join("\n");
-  if (additions.length === 0) {
-    return { addedKeys, content: body, filledKeys };
-  }
-  const separator = body === "" || body.endsWith("\n") ? "" : "\n";
-  return { addedKeys, content: `${body}${separator}${additions.join("\n")}
-`, filledKeys };
-};
-const fillDevSecrets = (deps) => {
-  const devVariablesPath = join(deps.cwd, DEV_VARS_FILE);
-  const exists = existsSync(devVariablesPath);
-  const existingContent = exists ? readFileSync(devVariablesPath, "utf8") : "";
-  const plan = planDevSecretsFill({ existingContent, randomHex: deps.randomHex });
-  if (plan.filledKeys.length === 0 && plan.addedKeys.length === 0) {
-    return { addedKeys: [], filledKeys: [], status: "unchanged" };
-  }
-  const temporaryPath = `${devVariablesPath}.tmp-${String(process.pid)}`;
-  try {
-    writeFileSync(temporaryPath, plan.content, { encoding: "utf8", mode: 384 });
-    renameSync(temporaryPath, devVariablesPath);
-  } catch (error) {
-    rmSync(temporaryPath, { force: true });
-    throw error;
-  }
-  const generated = [...plan.filledKeys, ...plan.addedKeys];
-  deps.info?.(`Generated ${String(generated.length)} dev secret(s) in ${DEV_VARS_FILE}: ${generated.join(", ")}`);
-  return { addedKeys: plan.addedKeys, filledKeys: plan.filledKeys, status: exists ? "filled" : "created" };
-};
-
-export { buildPackageSecretsBlock, ensureDevVariables, ensureDevVariablesExample as ensureDevVarsExample, fillDevSecrets, generateSecretValue, isMintableSecretKey, isPlaceholderValue, planDevSecretsFill, planDevVariablesAugment, planDevVariablesScaffold, requiredSecrets };

package/dist/packem_shared/classifyPolicyEdit-BHeAqF8P.mjs

@@ -1,99 +0,0 @@
-import { Project, SyntaxKind } from 'ts-morph';
-
-const TERMINAL_METHODS = /* @__PURE__ */ new Set(["action", "mutation", "query", "stream"]);
-const IDENTIFIER_PATTERN = /^[A-Za-z_$][\w$]*$/u;
-const ADDITIVE_KINDS = /* @__PURE__ */ new Set(["scaffoldPolicy", "wireRls"]);
-const classifyPolicyEdit = (edit) => ADDITIVE_KINDS.has(edit.kind) ? "additive" : "destructive";
-const scaffoldPolicyFile = (edit) => {
-  if (typeof edit.name !== "string" || typeof edit.table !== "string" || !IDENTIFIER_PATTERN.test(edit.name) || !IDENTIFIER_PATTERN.test(edit.table)) {
-    return { ok: false, reason: "invalid-identifier" };
-  }
-  const policiesIdentifier = `${edit.name}Policies`;
-  const rolesIdentifier = `${edit.name}Roles`;
-  const table = JSON.stringify(edit.table);
-  const source = `import { definePermission, definePolicies, definePolicy, defineRole } from "@lunora/server";
-
-/**
- * Access rules for the ${edit.table} table — scaffolded by the Lunora studio
- * (plan 025). The \`when\` predicates below DENY by default (\`() => false\`);
- * replace each TODO with the real condition, then wire \`${policiesIdentifier}\`
- * into the procedures that read/write ${edit.table} via
- * \`.use(rls(${policiesIdentifier}, { roles: ${rolesIdentifier} }))\`.
- */
-export const ${policiesIdentifier} = definePolicies([
-    definePolicy({
-        on: "read",
-        table: ${table},
-        // TODO: return \`true\` to allow, a \`WhereInput\` to filter, or \`false\` to deny.
-        when: () => false,
-    }),
-]);
-
-/** Named permissions \`${policiesIdentifier}\` can check with \`ctx.auth.can(...)\`. */
-export const ${edit.name}View = definePermission("${edit.name}:view");
-
-/** Roles that grant the permissions above; register via \`rls(policies, { roles })\`. */
-export const ${rolesIdentifier} = [defineRole("${edit.name}-admin", { permissions: [${edit.name}View] })];
-`;
-  return { fileName: `${edit.name}.policies.ts`, ok: true, source };
-};
-const builderReceiver = (initializer) => {
-  const callee = initializer.getExpression();
-  if (callee.getKind() !== SyntaxKind.PropertyAccessExpression) {
-    return void 0;
-  }
-  const access = callee.asKindOrThrow(SyntaxKind.PropertyAccessExpression);
-  return TERMINAL_METHODS.has(access.getName()) ? access.getExpression() : void 0;
-};
-const ensureRlsImport = (sourceFile) => {
-  const serverImport = sourceFile.getImportDeclaration((declaration) => declaration.getModuleSpecifierValue() === "@lunora/server");
-  if (serverImport === void 0) {
-    sourceFile.addImportDeclaration({ moduleSpecifier: "@lunora/server", namedImports: ["rls"] });
-    return;
-  }
-  if (!serverImport.getNamedImports().some((named) => named.getName() === "rls")) {
-    serverImport.addNamedImport("rls");
-  }
-};
-const chainHasRls = (receiver) => {
-  const calls = receiver.getDescendantsOfKind(SyntaxKind.CallExpression);
-  if (receiver.getKind() === SyntaxKind.CallExpression) {
-    calls.push(receiver.asKindOrThrow(SyntaxKind.CallExpression));
-  }
-  for (const call of calls) {
-    const callee = call.getExpression();
-    if (callee.getKind() !== SyntaxKind.PropertyAccessExpression) {
-      continue;
-    }
-    const access = callee.asKindOrThrow(SyntaxKind.PropertyAccessExpression);
-    const [argument] = call.getArguments();
-    if (access.getName() === "use" && argument?.getKind() === SyntaxKind.CallExpression && argument.asKindOrThrow(SyntaxKind.CallExpression).getExpression().getText() === "rls") {
-      return true;
-    }
-  }
-  return false;
-};
-const wireRlsIntoProcedure = (source, edit) => {
-  if (typeof edit.policies !== "string" || !IDENTIFIER_PATTERN.test(edit.policies)) {
-    return { ok: false, reason: "invalid-identifier" };
-  }
-  const project = new Project({ compilerOptions: { allowJs: true }, useInMemoryFileSystem: true });
-  const sourceFile = project.createSourceFile("procedure.ts", source, { overwrite: true });
-  const declaration = sourceFile.getVariableDeclaration(edit.exportName);
-  const initializer = declaration?.getInitializer();
-  if (declaration === void 0 || initializer?.getKind() !== SyntaxKind.CallExpression) {
-    return { ok: false, reason: "unknown-procedure" };
-  }
-  const receiver = builderReceiver(initializer.asKindOrThrow(SyntaxKind.CallExpression));
-  if (receiver === void 0) {
-    return { ok: false, reason: "unsupported-procedure-shape" };
-  }
-  if (chainHasRls(receiver)) {
-    return { ok: false, reason: "already-wired" };
-  }
-  receiver.replaceWithText(`${receiver.getText()}.use(rls(${edit.policies}))`);
-  ensureRlsImport(sourceFile);
-  return { ok: true, text: sourceFile.getFullText() };
-};
-
-export { classifyPolicyEdit, scaffoldPolicyFile, wireRlsIntoProcedure };

package/dist/packem_shared/collectWranglerSecretVariables-BRWIvT-e.mjs

@@ -1,56 +0,0 @@
-import { relative } from 'node:path';
-import { secretKindOf, redact } from '@lunora/codegen';
-import { isPlaceholderValue } from './buildPackageSecretsBlock-BxOcyaAY.mjs';
-import { findWranglerFile, readWranglerJsonc } from './WRANGLER_FILES-DwSuC-Kn.mjs';
-
-const MIN_SECRET_NAMED_VALUE_LENGTH = 8;
-const SECRET_WORD_TOKENS = /* @__PURE__ */ new Set(["CREDENTIAL", "CREDENTIALS", "DSN", "PASSPHRASE", "PASSWD", "PASSWORD", "SECRET", "TOKEN"]);
-const SECRET_KEY_SUFFIXES = ["ACCESS_KEY", "API_KEY", "ENCRYPTION_KEY", "PRIVATE_KEY", "SIGNING_KEY"];
-const PUBLIC_KEY_TOKENS = /* @__PURE__ */ new Set(["PUBLIC", "PUBLISHABLE"]);
-const KEY_SEPARATOR_RE = /[_-]/u;
-const keyTokens = (key) => key.toUpperCase().split(KEY_SEPARATOR_RE);
-const isSecretKeyName = (key) => {
-  const normalized = key.toUpperCase().replaceAll("-", "_");
-  if (keyTokens(key).some((token) => SECRET_WORD_TOKENS.has(token))) {
-    return true;
-  }
-  return SECRET_KEY_SUFFIXES.some((suffix) => normalized === suffix || normalized.endsWith(`_${suffix}`));
-};
-const isPublicKeyName = (key) => keyTokens(key).some((token) => PUBLIC_KEY_TOKENS.has(token));
-const scanWranglerVariablesForSecrets = (variables, file) => {
-  if (variables === void 0) {
-    return [];
-  }
-  const findings = [];
-  for (const [key, rawValue] of Object.entries(variables)) {
-    if (typeof rawValue !== "string") {
-      continue;
-    }
-    if (isPlaceholderValue(rawValue)) {
-      continue;
-    }
-    if (isPublicKeyName(key)) {
-      continue;
-    }
-    const shapeKind = secretKindOf(rawValue);
-    const kind = shapeKind ?? (isSecretKeyName(key) && rawValue.length >= MIN_SECRET_NAMED_VALUE_LENGTH ? "secret_named_var" : void 0);
-    if (kind === void 0) {
-      continue;
-    }
-    findings.push({ file, key, kind, preview: redact(rawValue) });
-  }
-  return findings;
-};
-const collectWranglerSecretVariables = (projectRoot) => {
-  const wranglerPath = findWranglerFile(projectRoot);
-  if (wranglerPath === void 0) {
-    return [];
-  }
-  const { parsed } = readWranglerJsonc(wranglerPath);
-  if (parsed === void 0) {
-    return [];
-  }
-  return scanWranglerVariablesForSecrets(parsed.vars, relative(projectRoot, wranglerPath));
-};
-
-export { collectWranglerSecretVariables, scanWranglerVariablesForSecrets };

package/dist/packem_shared/createConfirm-BMikeJC9.mjs

@@ -1,117 +0,0 @@
-import { createInterface } from 'node:readline';
-
-const MULTI_SELECT_SEPARATOR = /[\s,]+/u;
-const isInteractive = () => process.stdin.isTTY;
-const promptYesNo = async (prompt, options) => {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    const answer = await new Promise((resolve) => {
-      rl.question(prompt, (input) => {
-        resolve(input);
-      });
-    });
-    const normalised = answer.trim().toLowerCase();
-    if (normalised === "") {
-      return options?.defaultYes === true;
-    }
-    return normalised === "y" || normalised === "yes";
-  } finally {
-    rl.close();
-  }
-};
-const createConfirm = (prefix = "") => isInteractive() ? (message) => promptYesNo(`${prefix}${message} [Y/n] `, { defaultYes: true }) : () => Promise.resolve(false);
-const promptSelect = async (message, options, settings) => {
-  if (!isInteractive() || options.length === 0) {
-    return settings?.default;
-  }
-  const defaultIndex = settings?.default === void 0 ? -1 : options.findIndex((option) => option.value === settings.default);
-  const lines = options.map(
-    (option, index) => `  ${String(index + 1)}) ${option.label}${option.description === void 0 ? "" : ` — ${option.description}`}`
-  );
-  const promptMessage = `${message}
-${lines.join("\n")}
-> ${defaultIndex >= 0 ? `[${String(defaultIndex + 1)}] ` : ""}`;
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    const answer = await new Promise((resolve) => {
-      rl.question(promptMessage, (input) => {
-        resolve(input);
-      });
-    });
-    const trimmed = answer.trim();
-    if (trimmed === "") {
-      return settings?.default;
-    }
-    const choice = Number.parseInt(trimmed, 10);
-    if (Number.isInteger(choice) && choice >= 1 && choice <= options.length) {
-      return options[choice - 1]?.value;
-    }
-    const byText = options.find((option) => option.value === trimmed || option.label.toLowerCase() === trimmed.toLowerCase());
-    return byText?.value ?? settings?.default;
-  } finally {
-    rl.close();
-  }
-};
-const promptText = async (message, settings) => {
-  if (!isInteractive()) {
-    return settings?.default;
-  }
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    const answer = await new Promise((resolve) => {
-      rl.question(message, (input) => {
-        resolve(input);
-      });
-    });
-    const trimmed = answer.trim();
-    return trimmed === "" ? settings?.default : trimmed;
-  } finally {
-    rl.close();
-  }
-};
-const promptMultiSelect = async (message, options, settings) => {
-  const defaults = settings?.defaults ?? [];
-  if (!isInteractive() || options.length === 0) {
-    return [...defaults];
-  }
-  const lines = options.map(
-    (option, index) => `  ${String(index + 1)}) ${option.label}${option.description === void 0 ? "" : ` — ${option.description}`}`
-  );
-  const defaultHint = defaults.length === 0 ? "" : `[${defaults.join(", ")}] `;
-  const promptMessage = `${message} (comma-separated; Enter for default)
-${lines.join("\n")}
-> ${defaultHint}`;
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    const answer = await new Promise((resolve) => {
-      rl.question(promptMessage, (input) => {
-        resolve(input);
-      });
-    });
-    const trimmed = answer.trim();
-    if (trimmed === "") {
-      return [...defaults];
-    }
-    const tokens = trimmed.split(MULTI_SELECT_SEPARATOR).map((token) => token.trim()).filter((token) => token !== "");
-    const picked = /* @__PURE__ */ new Set();
-    for (const token of tokens) {
-      const choice = Number.parseInt(token, 10);
-      if (Number.isInteger(choice) && choice >= 1 && choice <= options.length && String(choice) === token) {
-        const byIndex = options[choice - 1]?.value;
-        if (byIndex !== void 0) {
-          picked.add(byIndex);
-        }
-        continue;
-      }
-      const byText = options.find((option) => option.value === token || option.label.toLowerCase() === token.toLowerCase());
-      if (byText !== void 0) {
-        picked.add(byText.value);
-      }
-    }
-    return options.filter((option) => picked.has(option.value)).map((option) => option.value);
-  } finally {
-    rl.close();
-  }
-};
-
-export { createConfirm, isInteractive, promptMultiSelect, promptSelect, promptText, promptYesNo };

package/dist/packem_shared/detectFramework-U08038Yp.mjs

@@ -1,41 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-const FRAMEWORK_SIGNATURES = [
-  { class: "A", dependency: "@tanstack/react-start", framework: "tanstack-start" },
-  { class: "A", dependency: "@tanstack/solid-start", framework: "tanstack-start-solid" },
-  { class: "A", dependency: "@react-router/dev", framework: "react-router" },
-  { class: "A", dependency: "@solidjs/start", framework: "solid-start" },
-  { class: "A", dependency: "solid-start", framework: "solid-start" },
-  { class: "B", dependency: "@sveltejs/kit", framework: "sveltekit" },
-  { class: "B", dependency: "nuxt", framework: "nuxt" },
-  { class: "B", dependency: "astro", framework: "astro" }
-];
-const STANDALONE = { class: "C", framework: "none" };
-const readProjectDependencyNames = (root) => {
-  const packageJsonPath = join(root, "package.json");
-  if (!existsSync(packageJsonPath)) {
-    return /* @__PURE__ */ new Set();
-  }
-  try {
-    const raw = readFileSync(packageJsonPath, "utf8");
-    const parsed = JSON.parse(raw);
-    return /* @__PURE__ */ new Set([...Object.keys(parsed.dependencies ?? {}), ...Object.keys(parsed.devDependencies ?? {})]);
-  } catch {
-    return /* @__PURE__ */ new Set();
-  }
-};
-const detectFramework = (root) => {
-  const dependencies = readProjectDependencyNames(root);
-  if (dependencies.size === 0) {
-    return STANDALONE;
-  }
-  for (const signature of FRAMEWORK_SIGNATURES) {
-    if (dependencies.has(signature.dependency)) {
-      return { class: signature.class, framework: signature.framework };
-    }
-  }
-  return STANDALONE;
-};
-
-export { detectFramework, readProjectDependencyNames };

package/dist/packem_shared/discoverAgentInfo-eXA3hF4v.mjs

@@ -1,19 +0,0 @@
-import { existsSync } from 'node:fs';
-import { AGENTS_FILENAME, discoverAgents } from '@lunora/codegen';
-import { Project } from 'ts-morph';
-import { join } from 'node:path';
-
-const discoverAgentInfo = (projectRoot, schemaDirectory) => {
-  const agentsPath = join(projectRoot, schemaDirectory, AGENTS_FILENAME);
-  if (!existsSync(agentsPath)) {
-    return { agents: [] };
-  }
-  try {
-    const project = new Project({ skipAddingFilesFromTsConfig: true, useInMemoryFileSystem: false });
-    return { agents: discoverAgents(project, join(projectRoot, schemaDirectory)) };
-  } catch (error) {
-    return { agents: [], error: error instanceof Error ? error.message : String(error) };
-  }
-};
-
-export { discoverAgentInfo };

package/dist/packem_shared/discoverContainerInfo-BXFs6Wav.mjs

@@ -1,19 +0,0 @@
-import { existsSync } from 'node:fs';
-import { CONTAINERS_FILENAME, discoverContainers } from '@lunora/codegen';
-import { Project } from 'ts-morph';
-import { join } from 'node:path';
-
-const discoverContainerInfo = (projectRoot, schemaDirectory) => {
-  const containersPath = join(projectRoot, schemaDirectory, CONTAINERS_FILENAME);
-  if (!existsSync(containersPath)) {
-    return { containers: [] };
-  }
-  try {
-    const project = new Project({ skipAddingFilesFromTsConfig: true, skipFileDependencyResolution: true, useInMemoryFileSystem: false });
-    return { containers: discoverContainers(project, join(projectRoot, schemaDirectory)) };
-  } catch (error) {
-    return { containers: [], error: error instanceof Error ? error.message : String(error) };
-  }
-};
-
-export { discoverContainerInfo };

package/dist/packem_shared/discoverSchemaInfo-BB-CKlTK.mjs

@@ -1,25 +0,0 @@
-import { existsSync } from 'node:fs';
-import { discoverSchema } from '@lunora/codegen';
-import { Project } from 'ts-morph';
-import { join } from 'node:path';
-
-const discoverSchemaInfo = (projectRoot, schemaDirectory) => {
-  const schemaPath = join(projectRoot, schemaDirectory, "schema.ts");
-  if (!existsSync(schemaPath)) {
-    return { info: void 0 };
-  }
-  try {
-    const project = new Project({ skipAddingFilesFromTsConfig: true, useInMemoryFileSystem: false });
-    const schema = discoverSchema(project, schemaPath, projectRoot);
-    return {
-      info: {
-        hasGlobalTable: schema.tables.some((table) => table.shardMode === "global"),
-        vectorIndexNames: schema.vectorIndexes.map((index) => index.name)
-      }
-    };
-  } catch (error) {
-    return { error: error instanceof Error ? error.message : String(error), info: void 0 };
-  }
-};
-
-export { discoverSchemaInfo };