@holo-js/cli 0.2.6 → 0.3.0

package/dist/{chunk-LXGQCG56.mjs → chunk-OLZEMIDQ.mjs}

@@ -1,6 +1,6 @@
 import {
   fileExists
-} from "./chunk-LBJAJLKU.mjs";
+} from "./chunk-M3IPUCTM.mjs";
 
 // src/migrations.ts
 import { join } from "path";

package/dist/{chunk-VP2E62DF.mjs → chunk-QSVMXMTQ.mjs}

@@ -1,349 +1,56 @@
 import {
   loadGeneratedProjectRegistry,
   writeGeneratedProjectRegistry
-} from "./chunk-J76GH2DR.mjs";
+} from "./chunk-R4ZYMEDU.mjs";
+import {
+  assertUniqueCommandTokens,
+  assertUniqueEntries,
+  captureAuthorizationDefinitionNames,
+  collectFiles,
+  deriveBroadcastNameFromPath,
+  deriveChannelPatternFromPath,
+  deriveCommandNameFromPath,
+  deriveEventNameFromPath,
+  deriveJobNameFromPath,
+  deriveListenerIdFromPath,
+  findAddedAuthorizationDefinitionNames,
+  inferMigrationNameFromEntry,
+  isCliModelReference,
+  isInactiveGeneratedModelModule,
+  isMigrationDefinition,
+  isMissingGeneratedSchemaModelError,
+  isSeederDefinition,
+  normalizeCommandAliases,
+  resolveAuthorizationTargetName,
+  resolveBroadcastArtifactsPath,
+  resolveCommandExport,
+  resolveDiscoveredJobMetadata,
+  resolveListenerEventNamesForDiscovery,
+  resolveListenerEventNamesFromSource,
+  resolveNamedExport,
+  resolveNamedExportEntry,
+  resolveRegisteredPath,
+  unregisterAuthorizationDefinitionNames,
+  validateMigrationName
+} from "./chunk-TRYHX5S4.mjs";
 import {
-  COMMAND_FILE_PATTERN,
-  MIGRATION_NAME_PATTERN,
   hasEventDefinitionMarker,
   hasListenerDefinitionMarker,
   importProjectModule,
-  isRecord,
   loadAuthorizationDiscoveryModule,
   loadBroadcastDiscoveryModule,
   loadEventsDiscoveryModule,
   loadQueueDiscoveryModule,
   makeProjectRelativePath,
-  pathExists,
-  readTextFile,
-  toPosixPath
-} from "./chunk-ILU426CF.mjs";
+  pathExists
+} from "./chunk-YACY2572.mjs";
 
 // src/project/discovery.ts
-import { resolve as resolve2 } from "path";
+import { resolve } from "path";
 import { loadConfigDirectory } from "@holo-js/config";
 import {
   normalizeHoloProjectConfig
-} from "@holo-js/db";
-
-// src/project/discovery-helpers.ts
-import { readdir } from "fs/promises";
-import { basename, dirname, extname, join, relative, resolve } from "path";
-async function collectFiles(root) {
-  if (!await pathExists(root)) {
-    return [];
-  }
-  const entries = await readdir(root, { withFileTypes: true });
-  const files = [];
-  for (const entry of entries) {
-    const target = join(root, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...await collectFiles(target));
-      continue;
-    }
-    if (entry.isFile() && COMMAND_FILE_PATTERN.test(entry.name)) {
-      files.push(target);
-    }
-  }
-  return files;
-}
-function deriveCommandNameFromPath(commandsRoot, sourcePath) {
-  const relativePath = toPosixPath(relative(commandsRoot, sourcePath));
-  return relativePath.replace(COMMAND_FILE_PATTERN, "").split("/").filter(Boolean).join(":");
-}
-function deriveJobNameFromPath(jobsRoot, sourcePath) {
-  const relativePath = toPosixPath(relative(jobsRoot, sourcePath));
-  return relativePath.replace(COMMAND_FILE_PATTERN, "").split("/").filter(Boolean).join(".");
-}
-function deriveDottedNameFromPath(root, sourcePath, emptyMessage) {
-  const relativePath = toPosixPath(relative(root, sourcePath)).replace(COMMAND_FILE_PATTERN, "");
-  const derived = relativePath.split("/").map((part) => part.trim()).filter(Boolean).join(".");
-  if (!derived) {
-    throw new Error(emptyMessage);
-  }
-  return derived;
-}
-function deriveEventNameFromPath(eventsRoot, sourcePath) {
-  return deriveDottedNameFromPath(eventsRoot, sourcePath, "[Holo Events] Derived event names require a non-empty source path.");
-}
-function deriveListenerIdFromPath(listenersRoot, sourcePath) {
-  return deriveDottedNameFromPath(listenersRoot, sourcePath, "[Holo Events] Derived listener identifiers require a non-empty source path.");
-}
-function deriveBroadcastNameFromPath(root, sourcePath) {
-  return deriveDottedNameFromPath(root, sourcePath, "[Holo Broadcast] Derived broadcast names require a non-empty source path.");
-}
-function deriveChannelPatternFromPath(root, sourcePath) {
-  return deriveDottedNameFromPath(root, sourcePath, "[Holo Broadcast] Derived channel patterns require a non-empty source path.");
-}
-function resolveDiscoveredJobMetadata(job, sourcePath, derivedName, queueConfig) {
-  const connection = job.connection ?? queueConfig.default;
-  let queue = job.queue;
-  if (!queue) {
-    const configuredConnection = queueConfig.connections[connection];
-    queue = configuredConnection ? configuredConnection.queue : "default";
-  }
-  return {
-    sourcePath,
-    name: derivedName,
-    connection,
-    queue,
-    ...typeof job.tries === "number" ? { tries: job.tries } : {},
-    ...typeof job.backoff !== "undefined" ? { backoff: job.backoff } : {},
-    ...typeof job.timeout === "number" ? { timeout: job.timeout } : {}
-  };
-}
-function isAppCommand(value) {
-  return isRecord(value) && typeof value.description === "string" && typeof value.run === "function";
-}
-function resolveCommandExport(moduleValue) {
-  if (isRecord(moduleValue) && isAppCommand(moduleValue.default)) {
-    return moduleValue.default;
-  }
-  if (isRecord(moduleValue)) {
-    for (const value of Object.values(moduleValue)) {
-      if (isAppCommand(value)) {
-        return value;
-      }
-    }
-  }
-  return void 0;
-}
-function normalizeCommandAliases(value) {
-  if (!value) {
-    return void 0;
-  }
-  const normalized = [...new Set(value.map((alias) => alias.trim()).filter(Boolean))];
-  return normalized.length > 0 ? normalized : void 0;
-}
-function assertUniqueEntries(kind, entries) {
-  const seen = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const existing = seen.get(entry.name);
-    if (existing) {
-      throw new Error(`Discovered duplicate ${kind} "${entry.name}" in "${existing}" and "${entry.sourcePath}".`);
-    }
-    seen.set(entry.name, entry.sourcePath);
-  }
-}
-function assertUniqueCommandTokens(entries) {
-  const seen = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    for (const token of [entry.name, ...entry.aliases]) {
-      const existing = seen.get(token);
-      if (existing) {
-        throw new Error(`Discovered duplicate command token "${token}" in "${existing}" and "${entry.sourcePath}".`);
-      }
-      seen.set(token, entry.sourcePath);
-    }
-  }
-}
-function resolveRegisteredPath(projectRoot, entry) {
-  return resolve(projectRoot, entry);
-}
-function resolveNamedExport(moduleValue, matcher) {
-  if (!isRecord(moduleValue)) return void 0;
-  if (matcher(moduleValue.default)) return moduleValue.default;
-  for (const value of Object.values(moduleValue)) {
-    if (matcher(value)) return value;
-  }
-  return void 0;
-}
-function resolveNamedExportEntry(moduleValue, matcher) {
-  if (!isRecord(moduleValue)) return void 0;
-  if (matcher(moduleValue.default)) {
-    return { exportName: "default", value: moduleValue.default };
-  }
-  for (const [exportName, value] of Object.entries(moduleValue)) {
-    if (matcher(value)) return { exportName, value };
-  }
-  return void 0;
-}
-function isCliModelReference(value) {
-  return isRecord(value) && isRecord(value.definition) && value.definition.kind === "model" && typeof value.definition.name === "string" && typeof value.prune === "function";
-}
-function isMissingGeneratedSchemaModelError(error) {
-  return error instanceof Error && error.message.includes("is not present in the generated schema registry");
-}
-function isInactiveGeneratedModelModule(value) {
-  return isRecord(value) && value.holoModelPendingSchema === true;
-}
-function isMigrationDefinition(value) {
-  return isRecord(value) && typeof value.up === "function";
-}
-function isSeederDefinition(value) {
-  return isRecord(value) && typeof value.name === "string" && typeof value.run === "function";
-}
-function resolveListenerEventNamesForDiscovery(listener, eventNamesByReference = /* @__PURE__ */ new Map()) {
-  return Object.freeze([...new Set(listener.listensTo.map((reference) => {
-    if (typeof reference === "string") {
-      return reference.trim();
-    }
-    if (typeof reference.name === "string" && reference.name.trim()) {
-      return reference.name.trim();
-    }
-    if (eventNamesByReference.has(reference)) {
-      return eventNamesByReference.get(reference);
-    }
-    throw new Error("[Holo Events] Listener event references must resolve to explicit event names before discovery registration.");
-  }))]);
-}
-function resolveAuthorizationTargetName(target) {
-  const modelFacadeTarget = target;
-  if (typeof modelFacadeTarget.definition?.name === "string" && modelFacadeTarget.definition.name.trim()) {
-    return modelFacadeTarget.definition.name.trim();
-  }
-  const namedTarget = target;
-  return typeof namedTarget.name === "string" && namedTarget.name.trim() ? namedTarget.name.trim() : void 0;
-}
-function captureAuthorizationDefinitionNames(definitions) {
-  return new Set(definitions.keys());
-}
-function findAddedAuthorizationDefinitionNames(definitions, existingNames) {
-  return [...definitions.keys()].filter((name) => !existingNames.has(name));
-}
-function unregisterAuthorizationDefinitionNames(authorizationDiscovery, policyNames, abilityNames) {
-  if (typeof authorizationDiscovery.authorizationInternals.unregisterPolicyDefinition !== "function" || typeof authorizationDiscovery.authorizationInternals.unregisterAbilityDefinition !== "function") {
-    authorizationDiscovery.authorizationInternals.resetAuthorizationRuntimeState?.();
-    return;
-  }
-  for (const policyName of policyNames) {
-    authorizationDiscovery.authorizationInternals.unregisterPolicyDefinition(policyName);
-  }
-  for (const abilityName of abilityNames) {
-    authorizationDiscovery.authorizationInternals.unregisterAbilityDefinition(abilityName);
-  }
-}
-function collectImportedBindingsBySource(sourceText) {
-  const bindings = /* @__PURE__ */ new Map();
-  const importPattern = /import\s+([\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g;
-  for (const match of sourceText.matchAll(importPattern)) {
-    const clause = match[1]?.trim();
-    const source = match[2]?.trim();
-    if (!clause || !source) {
-      continue;
-    }
-    const namedMatch = clause.match(/\{([\s\S]+)\}/);
-    const defaultClause = clause.replace(/\{[\s\S]+\}/, "").replace(/,$/, "").trim();
-    if (defaultClause && defaultClause !== "*") {
-      bindings.set(defaultClause, source);
-    }
-    if (namedMatch?.[1]) {
-      for (const specifier of namedMatch[1].split(",")) {
-        const trimmed = specifier.trim();
-        if (!trimmed) {
-          continue;
-        }
-        const [imported, local] = trimmed.split(/\s+as\s+/);
-        const bindingName = (local ?? imported)?.trim();
-        if (bindingName) {
-          bindings.set(bindingName, source);
-        }
-      }
-    }
-  }
-  return bindings;
-}
-function extractListensToItems(sourceText) {
-  const markerIndex = sourceText.indexOf("listensTo");
-  if (markerIndex < 0) {
-    return [];
-  }
-  const colonIndex = sourceText.indexOf(":", markerIndex);
-  if (colonIndex < 0) {
-    return [];
-  }
-  let cursor = colonIndex + 1;
-  while (cursor < sourceText.length && /\s/.test(sourceText[cursor])) {
-    cursor += 1;
-  }
-  const startChar = sourceText[cursor];
-  let depth = 0;
-  let inString;
-  let expression = "";
-  for (; cursor < sourceText.length; cursor += 1) {
-    const char = sourceText[cursor];
-    expression += char;
-    if (inString) {
-      if (char === inString && sourceText[cursor - 1] !== "\\") {
-        inString = void 0;
-      }
-      continue;
-    }
-    if (char === "'" || char === '"' || char === "`") {
-      inString = char;
-      continue;
-    }
-    if (char === "[" || char === "{" || char === "(") {
-      depth += 1;
-      continue;
-    }
-    if (char === "]" || char === "}" || char === ")") {
-      depth -= 1;
-      if (depth === 0 && startChar === "[") {
-        break;
-      }
-      continue;
-    }
-    if (depth === 0 && startChar !== "[" && (char === "," || char === "\n" || char === "\r")) {
-      expression = expression.slice(0, -1);
-      break;
-    }
-  }
-  if (startChar !== "[") {
-    const item = expression.trim().replace(/\s+as\s+const$/, "");
-    return item ? [item] : [];
-  }
-  return expression.slice(1, -1).split(",").map((item) => item.trim().replace(/\s+as\s+const$/, "")).filter(Boolean);
-}
-async function resolveListenerEventNamesFromSource(projectRoot, listenerPath, discoveredEventNamesBySourcePath) {
-  const sourceText = await readTextFile(listenerPath) ?? "";
-  const bindingsByName = collectImportedBindingsBySource(sourceText);
-  const discoveredEventNamesByExtensionlessSourcePath = new Map(
-    [...discoveredEventNamesBySourcePath.entries()].map(([sourcePath, eventName]) => {
-      return [sourcePath.replace(/\.[^.]+$/, ""), eventName];
-    })
-  );
-  const resolvedEventNames = [];
-  for (const item of extractListensToItems(sourceText)) {
-    const quoted = item.match(/^['"](.+)['"]$/);
-    if (quoted) {
-      resolvedEventNames.push(quoted[1].trim());
-      continue;
-    }
-    const importSource = bindingsByName.get(item);
-    if (!importSource) {
-      throw new Error("[Holo Events] Listener event references must resolve to explicit event names before discovery registration.");
-    }
-    const importedPath = makeProjectRelativePath(projectRoot, resolve(dirname(listenerPath), importSource));
-    const eventName = discoveredEventNamesBySourcePath.get(importedPath) ?? discoveredEventNamesByExtensionlessSourcePath.get(importedPath.replace(/\.[^.]+$/, ""));
-    if (!eventName) {
-      throw new Error("[Holo Events] Listener event references must resolve to explicit event names before discovery registration.");
-    }
-    resolvedEventNames.push(eventName);
-  }
-  return Object.freeze([...new Set(resolvedEventNames)]);
-}
-function resolveBroadcastArtifactsPath(config, key) {
-  const configuredPaths = config.paths;
-  return configuredPaths[key] ?? `server/${key}`;
-}
-function inferMigrationNameFromEntry(entry) {
-  const fileName = basename(entry, extname(entry));
-  return validateMigrationName(
-    fileName,
-    `Registered migration "${entry}" must use a timestamped file name matching YYYY_MM_DD_HHMMSS_description.`
-  );
-}
-function validateMigrationName(name, message) {
-  if (!MIGRATION_NAME_PATTERN.test(name)) {
-    throw new Error(
-      message ?? `Migration name "${name}" must match YYYY_MM_DD_HHMMSS_description.`
-    );
-  }
-  return name;
-}
-
-// src/project/discovery.ts
+} from "@holo-js/kernel";
 function resolveBroadcastExportEntry(moduleValue, discovery) {
   if (!moduleValue || typeof moduleValue !== "object") {
     return void 0;
@@ -370,20 +77,20 @@ async function prepareProjectDiscovery(projectRoot, config = normalizeHoloProjec
   const loadedConfig = await loadConfigDirectory(projectRoot, {
     processEnv: process.env
   });
-  const modelsRoot = resolve2(projectRoot, config.paths.models);
-  const migrationsRoot = resolve2(projectRoot, config.paths.migrations);
-  const seedersRoot = resolve2(projectRoot, config.paths.seeders);
-  const commandsRoot = resolve2(projectRoot, config.paths.commands);
-  const jobsRoot = resolve2(projectRoot, config.paths.jobs);
-  const eventsRoot = resolve2(projectRoot, config.paths.events);
-  const listenersRoot = resolve2(projectRoot, config.paths.listeners);
+  const modelsRoot = resolve(projectRoot, config.paths.models);
+  const migrationsRoot = resolve(projectRoot, config.paths.migrations);
+  const seedersRoot = resolve(projectRoot, config.paths.seeders);
+  const commandsRoot = resolve(projectRoot, config.paths.commands);
+  const jobsRoot = resolve(projectRoot, config.paths.jobs);
+  const eventsRoot = resolve(projectRoot, config.paths.events);
+  const listenersRoot = resolve(projectRoot, config.paths.listeners);
   const broadcastPath = resolveBroadcastArtifactsPath(config, "broadcast");
   const channelsPath = resolveBroadcastArtifactsPath(config, "channels");
-  const broadcastRoot = resolve2(projectRoot, broadcastPath);
-  const channelsRoot = resolve2(projectRoot, channelsPath);
-  const policiesRoot = resolve2(projectRoot, config.paths.authorizationPolicies ?? "server/policies");
-  const abilitiesRoot = resolve2(projectRoot, config.paths.authorizationAbilities ?? "server/abilities");
-  const generatedSchemaPath = resolve2(projectRoot, config.paths.generatedSchema);
+  const broadcastRoot = resolve(projectRoot, broadcastPath);
+  const channelsRoot = resolve(projectRoot, channelsPath);
+  const policiesRoot = resolve(projectRoot, config.paths.authorizationPolicies ?? "server/policies");
+  const abilitiesRoot = resolve(projectRoot, config.paths.authorizationAbilities ?? "server/abilities");
+  const generatedSchemaPath = resolve(projectRoot, config.paths.generatedSchema);
   if (await pathExists(generatedSchemaPath)) {
     await importProjectModule(projectRoot, generatedSchemaPath);
   }
@@ -751,7 +458,7 @@ async function discoverAppCommands(projectRoot, config = normalizeHoloProjectCon
     description: entry.description,
     ...entry.usage ? { usage: entry.usage } : {},
     async load() {
-      const moduleValue = await importProjectModule(projectRoot, resolve2(projectRoot, entry.sourcePath));
+      const moduleValue = await importProjectModule(projectRoot, resolve(projectRoot, entry.sourcePath));
       const command = resolveCommandExport(moduleValue);
       if (!command) {
         throw new Error(`Discovered command "${entry.sourcePath}" does not export a Holo command.`);
@@ -801,13 +508,6 @@ async function loadRegisteredSeeders(projectRoot, config) {
 }
 
 export {
-  collectFiles,
-  resolveNamedExport,
-  resolveNamedExportEntry,
-  resolveListenerEventNamesForDiscovery,
-  collectImportedBindingsBySource,
-  extractListensToItems,
-  resolveListenerEventNamesFromSource,
   prepareProjectDiscovery,
   discoverAppCommands,
   loadRegisteredModels,