@open-tomato/rafa 0.35.0 → 0.37.0

package/dist/index-k6sd4ym5.js

@@ -0,0 +1,243 @@
+// @bun
+import {
+  commandProblem,
+  commandSpelling,
+  isRoutingWord,
+  isTopLevel
+} from "./index-3mzw3kzh.js";
+import {
+  describeValue
+} from "./index-fzhd3d4y.js";
+
+// src/cli/registry.ts
+var REFUSAL = "command registry";
+var HELP_WORD = "help";
+function mountKey(name) {
+  return `module/${name}`;
+}
+function pluralOf(name) {
+  return `${name}s`;
+}
+function rosterOf(commands, options = {}) {
+  return Object.freeze(options.includeHidden === true ? [...commands] : commands.filter((command) => command.hidden !== true));
+}
+function refuseHelpWord(word, as) {
+  if (word === HELP_WORD)
+    throw new Error(`${REFUSAL}: "${HELP_WORD}" is read as a help request, not ${as}`);
+}
+function indexSubjects(subjects) {
+  const names = new Map;
+  for (const subject of subjects) {
+    if (!isRoutingWord(subject.name) || typeof subject.summary !== "string") {
+      throw new TypeError(`${REFUSAL}: a subject has name ${describeValue(subject.name)} and summary ${describeValue(subject.summary)},` + " expected a word with no space, no slash and no leading dash, and a string");
+    }
+    refuseHelpWord(subject.name, "a subject");
+    if (names.has(subject.name))
+      throw new Error(`${REFUSAL}: subject "${subject.name}" is declared twice`);
+    names.set(subject.name, subject);
+  }
+  const words = new Map(names);
+  for (const subject of subjects) {
+    const plural = pluralOf(subject.name);
+    if (names.has(plural)) {
+      throw new Error(`${REFUSAL}: subject "${plural}" is spelled as the plural of subject "${subject.name}"`);
+    }
+    words.set(plural, subject);
+  }
+  return words;
+}
+function indexCommands(commands, subjects) {
+  const bySubject = new Map;
+  for (const command of commands) {
+    const problem = commandProblem(command);
+    if (problem !== null)
+      throw new TypeError(`${REFUSAL}: ${problem}`);
+    const spelling = commandSpelling(command);
+    if (isTopLevel(command)) {
+      refuseHelpWord(command.subject, "a command");
+      if (subjects.has(command.subject)) {
+        throw new Error(`${REFUSAL}: top-level command "${spelling}" is spelled as a subject`);
+      }
+    } else if (subjects.get(command.subject)?.name !== command.subject) {
+      throw new Error(`${REFUSAL}: command "${spelling}" is under subject "${command.subject}", which is not declared`);
+    }
+    const actions = bySubject.get(command.subject) ?? new Map;
+    if (actions.has(command.action))
+      throw new Error(`${REFUSAL}: command "${spelling}" is declared twice`);
+    actions.set(command.action, command);
+    bySubject.set(command.subject, actions);
+  }
+  return bySubject;
+}
+function topLevelOf(find, word) {
+  const command = find(word, word);
+  return command !== undefined && isTopLevel(command) ? command : undefined;
+}
+function shadowOf(words, find, subjects) {
+  const [first = "", second] = words;
+  if (words.length === 1)
+    return topLevelOf(find, first);
+  const subject = subjects.get(first);
+  if (words.length !== 2 || subject === undefined || second === undefined)
+    return;
+  return find(subject.name, second);
+}
+function typedAlias(alias) {
+  return alias.trim().split(/\s+/).join(" ");
+}
+function indexAliases(commands, find, subjects) {
+  const claimed = new Map;
+  const aliases = [];
+  for (const command of commands) {
+    const spelling = commandSpelling(command);
+    const lasting = new Set((command.lastingAliases ?? []).map(typedAlias));
+    for (const kept of lasting) {
+      if (!(command.aliases ?? []).map(typedAlias).includes(kept)) {
+        throw new Error(`${REFUSAL}: command "${spelling}" has lasting alias "${kept}", which is not one of its aliases`);
+      }
+    }
+    for (const alias of command.aliases ?? []) {
+      const typed = typedAlias(alias);
+      const words = Object.freeze(typed.split(" "));
+      if (!words.every(isRoutingWord)) {
+        throw new Error(`${REFUSAL}: command "${spelling}" has alias ${describeValue(alias)},` + " expected words with no slash and no leading dash");
+      }
+      refuseHelpWord(words[0] ?? "", "the first word of an alias");
+      const owner = claimed.get(typed);
+      if (owner !== undefined) {
+        throw new Error(`${REFUSAL}: alias "${typed}" is claimed by "${commandSpelling(owner)}" and by "${spelling}"`);
+      }
+      const shadow = shadowOf(words, find, subjects);
+      if (shadow !== undefined) {
+        throw new Error(`${REFUSAL}: alias "${typed}" of "${spelling}" is spelled as command "${commandSpelling(shadow)}"`);
+      }
+      claimed.set(typed, command);
+      aliases.push(Object.freeze({ words, command, lasting: lasting.has(typed) }));
+    }
+  }
+  return Object.freeze(aliases.sort((a, b) => b.words.length - a.words.length));
+}
+function checkMount(mount, held) {
+  if (typeof mount.name !== "string" || !/^[^\s-]\S*$/.test(mount.name)) {
+    throw new TypeError(`${REFUSAL}: a module is named ${describeValue(mount.name)}, expected a word with no leading dash`);
+  }
+  const label = `module "${mount.name}"`;
+  if (held.some((other) => other.name === mount.name))
+    throw new Error(`${REFUSAL}: ${label} is mounted twice`);
+  if (!Array.isArray(mount.commands)) {
+    throw new TypeError(`${REFUSAL}: ${label} has commands ${describeValue(mount.commands)}, expected a list`);
+  }
+  const actions = new Set;
+  for (const command of mount.commands) {
+    const problem = commandProblem(command);
+    if (problem !== null)
+      throw new TypeError(`${REFUSAL}: ${label}: ${problem}`);
+    if (command.exec === true) {
+      throw new Error(`${REFUSAL}: ${label}: action "${command.action}" declares exec, and a mounted action delegates to nothing`);
+    }
+    if (actions.has(command.action))
+      throw new Error(`${REFUSAL}: ${label}: action "${command.action}" is declared twice`);
+    actions.add(command.action);
+  }
+}
+function build(subjectList, commands, mounts) {
+  const subjects = indexSubjects(subjectList);
+  const bySubject = indexCommands(commands, subjects);
+  mounts.forEach((mount, index) => {
+    checkMount(mount, mounts.slice(0, index));
+  });
+  const mountsByName = new Map(mounts.map((mount) => [mount.name, mount]));
+  const mounted = new Map(mounts.map((mount) => [
+    mountKey(mount.name),
+    new Map(mount.commands.map((command) => [command.action, command]))
+  ]));
+  const find = (subject, action) => (bySubject.get(subject) ?? mounted.get(subject))?.get(action);
+  const aliases = indexAliases(commands, find, subjects);
+  const registry = {
+    subjects: () => subjectList,
+    subjectOf: (word) => subjects.get(word),
+    commands: (options) => rosterOf(commands, options),
+    actionsOf: (subject, options) => {
+      const mountedActions = mounted.get(subject);
+      if (mountedActions !== undefined)
+        return rosterOf([...mountedActions.values()], options);
+      const actions = [...bySubject.get(subject)?.values() ?? []].filter((command) => !isTopLevel(command));
+      return rosterOf(actions, options);
+    },
+    find,
+    topLevel: (word) => topLevelOf(find, word),
+    aliases: () => aliases,
+    mounts: () => mounts,
+    mountOf: (name) => mountsByName.get(name),
+    mount: (mount) => {
+      checkMount(mount, mounts);
+      return build(subjectList, commands, Object.freeze([
+        ...mounts,
+        Object.freeze({ name: mount.name, entry: mount.entry, commands: Object.freeze([...mount.commands]) })
+      ]));
+    }
+  };
+  return Object.freeze(registry);
+}
+function createCommandRegistry(input) {
+  return build(Object.freeze([...input.subjects]), Object.freeze([...input.commands]), Object.freeze([]));
+}
+
+// src/cli/describe.ts
+var DESCRIBE_SCHEMA_VERSION = 2;
+var DESCRIBE_BINARY = "rafa";
+function describeArg(arg) {
+  return {
+    name: arg.name,
+    description: arg.description,
+    type: arg.type,
+    required: arg.required === true,
+    default: arg.default ?? null
+  };
+}
+function describeFlag(flag) {
+  return { ...describeArg(flag), aliases: [...flag.aliases ?? []] };
+}
+function typedAlias2(alias) {
+  return alias.trim().split(/\s+/).join(" ");
+}
+function describeCommand(command, name, module) {
+  const { deprecated, spends } = command;
+  return {
+    name,
+    summary: command.summary,
+    description: command.description,
+    args: command.args.map(describeArg),
+    flags: command.flags.map(describeFlag),
+    examples: command.examples.map(({ cmd, note }) => ({ cmd, note })),
+    outputs: [...command.outputs],
+    aliases: module === null ? (command.aliases ?? []).map(typedAlias2) : [],
+    deprecated: deprecated === undefined ? null : { since: deprecated.since, use: deprecated.use },
+    module,
+    spends: spends === undefined ? null : { ...spends }
+  };
+}
+function mountedThrough(exec, registry) {
+  return registry.mounts().flatMap((mount) => registry.actionsOf(mountKey(mount.name)).map((command) => describeCommand(command, `${exec.action} ${mount.name} ${command.action}`, mount.name)));
+}
+function describeRoster(commands, registry) {
+  return [
+    ...commands.map((command) => describeCommand(command, command.action, null)),
+    ...commands.filter((command) => command.exec === true).flatMap((exec) => mountedThrough(exec, registry))
+  ];
+}
+function describeRegistry(registry, version) {
+  return {
+    schemaVersion: DESCRIBE_SCHEMA_VERSION,
+    binary: DESCRIBE_BINARY,
+    version,
+    subjects: registry.subjects().map((subject) => ({
+      name: subject.name,
+      summary: subject.summary,
+      actions: describeRoster(registry.actionsOf(subject.name), registry)
+    })),
+    commands: describeRoster(registry.commands().filter(isTopLevel), registry)
+  };
+}
+
+export { mountKey, pluralOf, createCommandRegistry, DESCRIBE_SCHEMA_VERSION, DESCRIBE_BINARY, describeRegistry };

package/dist/index-wp8c28fd.js

@@ -0,0 +1,18 @@
+// @bun
+var __require = import.meta.require;
+
+// src/learning/identity.ts
+import { createHash } from "crypto";
+var GAP = 0.1;
+var SOURCE_STEP = 0.05;
+var CONFIDENCE_MIN = 0.3;
+var CONFIDENCE_MAX = 0.9;
+var WHITESPACE_RUN = /\s+/g;
+function actionHash(action) {
+  return createHash("sha256").update(action.trim().toLowerCase()).digest("hex");
+}
+function triggerKey(trigger) {
+  return trigger.trim().toLowerCase().replace(WHITESPACE_RUN, " ");
+}
+
+export { __require, GAP, SOURCE_STEP, CONFIDENCE_MIN, CONFIDENCE_MAX, actionHash, triggerKey };

package/dist/index.js

@@ -1,156 +1,161 @@
 // @bun
 import {
-  CONFIG_VERSIONS2,
-  STORE_BACKENDS2,
-  SYNC_STRATEGIES2,
-  BOARD_RELATIONSHIP_MODES2,
-  INJECT_MODES2,
-  OUTPUT_MODES2,
-  CLAUDE_SETTING_SOURCES2,
-  PR_PROVIDERS2,
-  RELEASE_AUTO2,
-  PREREQUISITE_KINDS2,
-  MODULE_SOURCE_KINDS2,
-  CONFIG_FILE2,
-  CONFIG_DEFAULTS2,
-  ConfigError2,
-  configFilePath2,
-  parseConfigText2,
-  resolveConfig2,
-  RAFA_BLOCK_KINDS2,
-  isRafaBlockKind2,
-  readRafaBlocks2,
-  REPORT_STATUSES2,
-  FINDING_KINDS2,
-  FINDING_SIGNALS2,
-  parseReport2
-} from "./index-2tjmxwvp.js";
-import {
-  EFFORT_KEY_PROJECTIONS2,
-  openNdjsonStore2,
-  SCOPE_DIR2,
-  INIT_COMMAND2,
-  DISK_FILE_SYSTEM2,
-  ScopeError2,
-  scopeAt2,
-  initHint2,
-  selfAndAncestors2,
-  resolveScope2,
-  openSqliteStore2,
-  readConfigFile2,
-  loadConfig2,
-  mergeStore2,
-  PORT_VERSIONS2,
-  createAdapterRegistry2,
-  CORE_ADAPTER_REGISTRY2,
-  TRUSTED_PERMISSIONS2,
-  WIRE_FORMAT2,
-  WIRE_VERSION2,
-  WireFormatError2,
-  WireExportRefusal2,
-  encodeWirePayload2,
-  decodeWirePayload2,
-  exportWirePayload2,
-  materialiseWirePayload2,
-  selectEffortStore2
-} from "./index-ckqfhynj.js";
-import"./index-hgcvjke7.js";
-import {
-  MANIFEST_VERSION2,
-  FEATURE_TYPES2,
-  OUTPUT_CHANNELS2,
-  RUNNING_MANIFEST_SEAMS2,
-  validateManifest2,
+  FEATURE_TYPES,
+  MANIFEST_VERSION,
+  OUTPUT_CHANNELS,
+  RUNNING_MANIFEST_SEAMS,
   collect,
+  plan,
   report,
   start,
-  plan
-} from "./index-dvrq9nfb.js";
+  validateManifest
+} from "./index-35ze56rz.js";
+import {
+  PLAN_BLOCK_KINDS,
+  PLAN_HEADER_FIELDS,
+  PROBE_TIMEOUT_MS,
+  loadPlanPrerequisites,
+  mergePlanPrerequisites,
+  parsePlan,
+  parsePrerequisites,
+  planPrerequisites,
+  prerequisitesPathForPlan,
+  renderInjection,
+  runPreflight,
+  runShellProbe
+} from "./index-7bb0fdb7.js";
 import {
-  PLAN_BLOCK_KINDS2,
-  PLAN_HEADER_FIELDS2,
-  parsePlan2,
-  parsePrerequisites2,
-  planPrerequisites2,
-  mergePlanPrerequisites2,
-  prerequisitesPathForPlan2,
-  loadPlanPrerequisites2,
-  PROBE_TIMEOUT_MS2,
-  runShellProbe2,
-  runPreflight2,
-  renderInjection2
-} from "./index-41vzahew.js";
+  CORE_ADAPTER_REGISTRY,
+  DISK_FILE_SYSTEM,
+  EFFORT_KEY_PROJECTIONS,
+  INIT_COMMAND,
+  PORT_VERSIONS,
+  SCOPE_DIR,
+  ScopeError,
+  TRUSTED_PERMISSIONS,
+  WIRE_FORMAT,
+  WIRE_VERSION,
+  WireExportRefusal,
+  WireFormatError,
+  createAdapterRegistry,
+  decodeWirePayload,
+  encodeWirePayload,
+  exportWirePayload,
+  initHint,
+  loadConfig,
+  materialiseWirePayload,
+  mergeStore,
+  openNdjsonStore,
+  openSqliteStore,
+  readConfigFile,
+  resolveScope,
+  scopeAt,
+  selectEffortStore,
+  selfAndAncestors
+} from "./index-1mxv55ec.js";
+import {
+  CONFIG_DEFAULTS,
+  CONFIG_FILE,
+  ConfigError,
+  FINDING_KINDS,
+  FINDING_SIGNALS,
+  MODULE_SOURCE_KINDS,
+  PREREQUISITE_KINDS,
+  RAFA_BLOCK_KINDS,
+  REPORT_STATUSES,
+  configFilePath,
+  isRafaBlockKind,
+  parseConfigText,
+  parseReport,
+  readRafaBlocks,
+  resolveConfig
+} from "./index-jfas157k.js";
+import"./index-d6d0942q.js";
+import"./index-k6sd4ym5.js";
+import"./index-3mzw3kzh.js";
+import {
+  BOARD_RELATIONSHIP_MODES,
+  CLAUDE_SETTING_SOURCES,
+  CONFIG_VERSIONS,
+  INJECT_MODES,
+  OUTPUT_MODES,
+  PR_PROVIDERS,
+  RELEASE_AUTO,
+  STORE_BACKENDS,
+  SYNC_STRATEGIES
+} from "./index-fzhd3d4y.js";
+import"./index-wp8c28fd.js";
 export {
-  BOARD_RELATIONSHIP_MODES2 as BOARD_RELATIONSHIP_MODES,
-  CLAUDE_SETTING_SOURCES2 as CLAUDE_SETTING_SOURCES,
-  CONFIG_DEFAULTS2 as CONFIG_DEFAULTS,
-  CONFIG_FILE2 as CONFIG_FILE,
-  CONFIG_VERSIONS2 as CONFIG_VERSIONS,
-  CORE_ADAPTER_REGISTRY2 as CORE_ADAPTER_REGISTRY,
-  ConfigError2 as ConfigError,
-  DISK_FILE_SYSTEM2 as DISK_FILE_SYSTEM,
-  EFFORT_KEY_PROJECTIONS2 as EFFORT_KEY_PROJECTIONS,
-  FEATURE_TYPES2 as FEATURE_TYPES,
-  FINDING_KINDS2 as FINDING_KINDS,
-  FINDING_SIGNALS2 as FINDING_SIGNALS,
-  INIT_COMMAND2 as INIT_COMMAND,
-  INJECT_MODES2 as INJECT_MODES,
-  MANIFEST_VERSION2 as MANIFEST_VERSION,
-  MODULE_SOURCE_KINDS2 as MODULE_SOURCE_KINDS,
-  OUTPUT_CHANNELS2 as OUTPUT_CHANNELS,
-  OUTPUT_MODES2 as OUTPUT_MODES,
-  PLAN_BLOCK_KINDS2 as PLAN_BLOCK_KINDS,
-  PLAN_HEADER_FIELDS2 as PLAN_HEADER_FIELDS,
-  PORT_VERSIONS2 as PORT_VERSIONS,
-  PREREQUISITE_KINDS2 as PREREQUISITE_KINDS,
-  PROBE_TIMEOUT_MS2 as PROBE_TIMEOUT_MS,
-  PR_PROVIDERS2 as PR_PROVIDERS,
-  RAFA_BLOCK_KINDS2 as RAFA_BLOCK_KINDS,
-  RELEASE_AUTO2 as RELEASE_AUTO,
-  REPORT_STATUSES2 as REPORT_STATUSES,
-  RUNNING_MANIFEST_SEAMS2 as RUNNING_MANIFEST_SEAMS,
-  SCOPE_DIR2 as SCOPE_DIR,
-  STORE_BACKENDS2 as STORE_BACKENDS,
-  SYNC_STRATEGIES2 as SYNC_STRATEGIES,
-  ScopeError2 as ScopeError,
-  TRUSTED_PERMISSIONS2 as TRUSTED_PERMISSIONS,
-  WIRE_FORMAT2 as WIRE_FORMAT,
-  WIRE_VERSION2 as WIRE_VERSION,
-  WireExportRefusal2 as WireExportRefusal,
-  WireFormatError2 as WireFormatError,
-  configFilePath2 as configFilePath,
-  createAdapterRegistry2 as createAdapterRegistry,
-  decodeWirePayload2 as decodeWirePayload,
-  collect as effortCollectCommand,
-  report as effortReportCommand,
-  encodeWirePayload2 as encodeWirePayload,
-  exportWirePayload2 as exportWirePayload,
-  initHint2 as initHint,
-  isRafaBlockKind2 as isRafaBlockKind,
-  loadConfig2 as loadConfig,
-  loadPlanPrerequisites2 as loadPlanPrerequisites,
-  materialiseWirePayload2 as materialiseWirePayload,
-  mergePlanPrerequisites2 as mergePlanPrerequisites,
-  mergeStore2 as mergeStore,
-  openNdjsonStore2 as openNdjsonStore,
-  openSqliteStore2 as openSqliteStore,
-  parseConfigText2 as parseConfigText,
-  parsePlan2 as parsePlan,
-  parsePrerequisites2 as parsePrerequisites,
-  parseReport2 as parseReport,
-  plan as planCommand,
-  planPrerequisites2 as planPrerequisites,
-  prerequisitesPathForPlan2 as prerequisitesPathForPlan,
-  readConfigFile2 as readConfigFile,
-  readRafaBlocks2 as readRafaBlocks,
-  renderInjection2 as renderInjection,
-  resolveConfig2 as resolveConfig,
-  resolveScope2 as resolveScope,
-  runPreflight2 as runPreflight,
-  runShellProbe2 as runShellProbe,
-  scopeAt2 as scopeAt,
-  selectEffortStore2 as selectEffortStore,
-  selfAndAncestors2 as selfAndAncestors,
+  validateManifest,
   start as startCommand,
-  validateManifest2 as validateManifest
+  selfAndAncestors,
+  selectEffortStore,
+  scopeAt,
+  runShellProbe,
+  runPreflight,
+  resolveScope,
+  resolveConfig,
+  renderInjection,
+  readRafaBlocks,
+  readConfigFile,
+  prerequisitesPathForPlan,
+  planPrerequisites,
+  plan as planCommand,
+  parseReport,
+  parsePrerequisites,
+  parsePlan,
+  parseConfigText,
+  openSqliteStore,
+  openNdjsonStore,
+  mergeStore,
+  mergePlanPrerequisites,
+  materialiseWirePayload,
+  loadPlanPrerequisites,
+  loadConfig,
+  isRafaBlockKind,
+  initHint,
+  exportWirePayload,
+  encodeWirePayload,
+  report as effortReportCommand,
+  collect as effortCollectCommand,
+  decodeWirePayload,
+  createAdapterRegistry,
+  configFilePath,
+  WireFormatError,
+  WireExportRefusal,
+  WIRE_VERSION,
+  WIRE_FORMAT,
+  TRUSTED_PERMISSIONS,
+  ScopeError,
+  SYNC_STRATEGIES,
+  STORE_BACKENDS,
+  SCOPE_DIR,
+  RUNNING_MANIFEST_SEAMS,
+  REPORT_STATUSES,
+  RELEASE_AUTO,
+  RAFA_BLOCK_KINDS,
+  PR_PROVIDERS,
+  PROBE_TIMEOUT_MS,
+  PREREQUISITE_KINDS,
+  PORT_VERSIONS,
+  PLAN_HEADER_FIELDS,
+  PLAN_BLOCK_KINDS,
+  OUTPUT_MODES,
+  OUTPUT_CHANNELS,
+  MODULE_SOURCE_KINDS,
+  MANIFEST_VERSION,
+  INJECT_MODES,
+  INIT_COMMAND,
+  FINDING_SIGNALS,
+  FINDING_KINDS,
+  FEATURE_TYPES,
+  EFFORT_KEY_PROJECTIONS,
+  DISK_FILE_SYSTEM,
+  ConfigError,
+  CORE_ADAPTER_REGISTRY,
+  CONFIG_VERSIONS,
+  CONFIG_FILE,
+  CONFIG_DEFAULTS,
+  CLAUDE_SETTING_SOURCES,
+  BOARD_RELATIONSHIP_MODES
 };

package/dist/learning/index.js

@@ -1,25 +1,25 @@
 // @bun
 import {
-  bless2,
-  promotable2,
-  merge2
-} from "../index-hgcvjke7.js";
+  bless,
+  merge,
+  promotable
+} from "../index-d6d0942q.js";
 import {
-  GAP2,
-  SOURCE_STEP2,
-  CONFIDENCE_MIN2,
-  CONFIDENCE_MAX2,
-  actionHash2,
-  triggerKey2
-} from "../index-21jcfatr.js";
+  CONFIDENCE_MAX,
+  CONFIDENCE_MIN,
+  GAP,
+  SOURCE_STEP,
+  actionHash,
+  triggerKey
+} from "../index-wp8c28fd.js";
 export {
-  CONFIDENCE_MAX2 as CONFIDENCE_MAX,
-  CONFIDENCE_MIN2 as CONFIDENCE_MIN,
-  GAP2 as GAP,
-  SOURCE_STEP2 as SOURCE_STEP,
-  actionHash2 as actionHash,
-  bless2 as bless,
-  merge2 as merge,
-  promotable2 as promotable,
-  triggerKey2 as triggerKey
+  triggerKey,
+  promotable,
+  merge,
+  bless,
+  actionHash,
+  SOURCE_STEP,
+  GAP,
+  CONFIDENCE_MIN,
+  CONFIDENCE_MAX
 };