@open-tomato/rafa 0.17.0 → 0.19.0

package/dist/{index-n3rw8rhr.js → index-cedghpva.js}

@@ -1,5 +1,8 @@
 // @bun
-var __require = import.meta.require;
+import {
+  CONFIDENCE_MAX,
+  CONFIDENCE_MIN
+} from "./index-wp8c28fd.js";
 
 // src/pr/types.ts
 var MERGE_METHODS = Object.freeze([
@@ -11,6 +14,65 @@ function isMergeMethod(value) {
   return typeof value === "string" && MERGE_METHODS.includes(value);
 }
 
+// src/schema/tiers.ts
+import { existsSync, realpathSync } from "fs";
+import { dirname, join } from "path";
+var SKILL_TIERS = ["project", "rafa", "user"];
+var INSTINCT_SCOPES = ["project", "user"];
+var CLAUDE_SKILLS_PATH = join(".claude", "skills");
+var RAFA_INSTINCTS_PATH = join(".rafa", "instincts");
+var BUNDLED_SKILLS_DIR = join("bundled", "skills");
+var BUNDLED_BIN_DIR = join("bundled", "bin");
+function isSkillTier(value) {
+  return SKILL_TIERS.includes(value);
+}
+function realEntry(entry) {
+  try {
+    return realpathSync(entry);
+  } catch {
+    return entry;
+  }
+}
+function bundledSkillsDirectory(entry) {
+  return join(dirname(realEntry(entry ?? Bun.main)), BUNDLED_SKILLS_DIR);
+}
+function bundledBinDirectory(entry) {
+  return join(dirname(realEntry(entry ?? Bun.main)), BUNDLED_BIN_DIR);
+}
+function skillTierDirectory(tier, seams) {
+  if (tier === "user")
+    return join(seams.home, CLAUDE_SKILLS_PATH);
+  if (tier === "rafa")
+    return bundledSkillsDirectory(seams.entry);
+  return seams.projectRoot === null ? null : join(seams.projectRoot, CLAUDE_SKILLS_PATH);
+}
+function resolveSkillTiers(seams) {
+  const located = [];
+  for (const tier of SKILL_TIERS) {
+    const dir = skillTierDirectory(tier, seams);
+    if (dir !== null)
+      located.push({ tier, dir });
+  }
+  return located;
+}
+function instinctScopeDirectory(scope, seams) {
+  if (scope === "user")
+    return join(seams.home, RAFA_INSTINCTS_PATH);
+  return seams.projectRoot === null ? null : join(seams.projectRoot, RAFA_INSTINCTS_PATH);
+}
+function resolveInstinctScopes(seams) {
+  const located = [];
+  for (const scope of INSTINCT_SCOPES) {
+    const dir = instinctScopeDirectory(scope, seams);
+    if (dir !== null)
+      located.push({ scope, dir });
+  }
+  return located;
+}
+function tierExists(dir) {
+  return existsSync(dir);
+}
+
 // src/utils/declaration.ts
 var DECLARATION_KEYS = [
   "agent",
@@ -255,6 +317,7 @@ var OUTPUT_MODES = ["text", "json"];
 var CLAUDE_SETTING_SOURCES = ["user", "project", "local"];
 var PR_PROVIDERS = ["gh", "none"];
 var RELEASE_AUTO = "auto";
+var TIER_SWITCHES = ["on", "off"];
 function accepted(value) {
   return { value, problems: [], extras: [] };
 }
@@ -289,7 +352,20 @@ var usdAmount = (raw, at) => {
 };
 var issueNumber = (raw, at) => typeof raw === "number" && Number.isSafeInteger(raw) && raw > 0 ? accepted(raw) : refused(at, raw, "an issue number, a whole number above zero");
 var dayCount = (raw, at) => typeof raw === "number" && Number.isSafeInteger(raw) && raw > 0 ? accepted(raw) : refused(at, raw, "a number of days, a whole number above zero");
+var confidence = (raw, at) => typeof raw === "number" && Number.isFinite(raw) && toHundredths(raw) >= toHundredths(CONFIDENCE_MIN) && toHundredths(raw) <= toHundredths(CONFIDENCE_MAX) ? accepted(raw) : refused(at, raw, `a confidence from ${String(CONFIDENCE_MIN)} to ${String(CONFIDENCE_MAX)}`);
+function toHundredths(value) {
+  return Math.round(value * 100);
+}
+var recurrenceCount = (raw, at) => typeof raw === "number" && Number.isSafeInteger(raw) && raw >= 1 ? accepted(raw) : refused(at, raw, "a count, a whole number of 1 or more");
 var releaseEnabled = (raw, at) => typeof raw === "boolean" || raw === RELEASE_AUTO ? accepted(raw) : refused(at, raw, `true, false or ${RELEASE_AUTO}`);
+var tierSwitch = oneOf(TIER_SWITCHES);
+var tierPin = (raw, at) => {
+  if (raw === false)
+    return accepted(false);
+  const tier = SKILL_TIERS.find((name) => name === raw);
+  return tier === undefined ? refused(at, raw, `false or one of: ${SKILL_TIERS.join(", ")}`) : accepted(tier);
+};
+var routeTarget = (raw, at) => raw === false || typeof raw === "string" && raw.trim() !== "" ? accepted(raw) : refused(at, raw, "false or an agent name");
 var GITHUB_LOGIN = /^[A-Za-z0-9][A-Za-z0-9-]*(?:\[bot\])?$/;
 function isGitHubLogin(value) {
   return typeof value === "string" && GITHUB_LOGIN.test(value);
@@ -394,4 +470,4 @@ var moduleSource = (raw, at) => {
   }));
 };
 
-export { __require, MERGE_METHODS, isMergeMethod, isAgentName, BUDGET_FLAG, parseBudgetUsd, parseTaskDeclaration, stripTaskDeclaration, resolveDeclarationFlags, isMapping, describeValue, messageOf, CONFIG_VERSIONS, STORE_BACKENDS, INJECT_MODES, OUTPUT_MODES, CLAUDE_SETTING_SOURCES, PR_PROVIDERS, RELEASE_AUTO, oneOf, text, flag, mergeMethod, usdAmount, issueNumber, dayCount, releaseEnabled, isGitHubLogin, githubLogin, listOf, subsetOf, PREREQUISITE_KINDS, REQUIRED_ITEM_KEYS, OPTIONAL_ITEM_KEYS, requiredPrerequisite, optionalPrerequisite, MODULE_SOURCE_KINDS, MODULE_SOURCE_KEYS, moduleSource };
+export { MERGE_METHODS, isMergeMethod, SKILL_TIERS, RAFA_INSTINCTS_PATH, BUNDLED_SKILLS_DIR, isSkillTier, realEntry, bundledBinDirectory, skillTierDirectory, resolveSkillTiers, resolveInstinctScopes, tierExists, isAgentName, BUDGET_FLAG, parseBudgetUsd, parseTaskDeclaration, stripTaskDeclaration, resolveDeclarationFlags, isMapping, describeValue, messageOf, CONFIG_VERSIONS, STORE_BACKENDS, INJECT_MODES, OUTPUT_MODES, CLAUDE_SETTING_SOURCES, PR_PROVIDERS, RELEASE_AUTO, oneOf, text, flag, mergeMethod, usdAmount, issueNumber, dayCount, confidence, recurrenceCount, releaseEnabled, tierSwitch, tierPin, routeTarget, isGitHubLogin, githubLogin, listOf, subsetOf, PREREQUISITE_KINDS, REQUIRED_ITEM_KEYS, OPTIONAL_ITEM_KEYS, requiredPrerequisite, optionalPrerequisite, MODULE_SOURCE_KINDS, MODULE_SOURCE_KEYS, moduleSource };

package/dist/index-d6d0942q.js

@@ -0,0 +1,218 @@
+// @bun
+import {
+  CONFIDENCE_MAX,
+  CONFIDENCE_MIN,
+  GAP,
+  SOURCE_STEP,
+  triggerKey
+} from "./index-wp8c28fd.js";
+
+// src/learning/bless.ts
+import { createHash } from "crypto";
+var HUNDREDTHS = 100;
+function hundredths(confidence) {
+  return Math.round(confidence * HUNDREDTHS);
+}
+function compareText(left, right) {
+  if (left < right) {
+    return -1;
+  }
+  if (left > right) {
+    return 1;
+  }
+  return 0;
+}
+function byTrust(left, right) {
+  return hundredths(right.confidence) - hundredths(left.confidence) || right.usage_count - left.usage_count || compareText(left.id, right.id);
+}
+function blessedRecords(held, minConfidence) {
+  const floor = hundredths(minConfidence);
+  return held.filter((each) => each.status === "active" && each.promoted_to === undefined && hundredths(each.confidence) >= floor).sort(byTrust);
+}
+function versionOf(instincts) {
+  return createHash("sha256").update(JSON.stringify(instincts)).digest("hex");
+}
+function bless(held, options) {
+  const instincts = blessedRecords(held, options.minConfidence);
+  return { version: versionOf(instincts), instincts };
+}
+function promotable(held, options) {
+  return blessedRecords(held, options.minConfidence).filter((each) => each.usage_count >= options.after);
+}
+// src/learning/merge.ts
+var HUNDREDTHS2 = 100;
+var GAP_H = Math.round(GAP * HUNDREDTHS2);
+var STEP_H = Math.round(SOURCE_STEP * HUNDREDTHS2);
+var MIN_H = Math.round(CONFIDENCE_MIN * HUNDREDTHS2);
+var MAX_H = Math.round(CONFIDENCE_MAX * HUNDREDTHS2);
+function hundredths2(confidence) {
+  return Math.round(confidence * HUNDREDTHS2);
+}
+function compareText2(left, right) {
+  if (left < right) {
+    return -1;
+  }
+  if (left > right) {
+    return 1;
+  }
+  return 0;
+}
+function byAge(left, right) {
+  return compareText2(left.created_at, right.created_at) || compareText2(left.id, right.id);
+}
+function byConfidence(left, right) {
+  return hundredths2(right.confidence) - hundredths2(left.confidence) || compareText2(left.id, right.id);
+}
+function sourcesOf(record) {
+  return record.sources !== undefined && record.sources.length > 0 ? [...new Set(record.sources)] : [record.id];
+}
+function withSource(record, sourceId) {
+  const sources = [...new Set([...record.sources ?? [], sourceId])].sort();
+  return { ...record, sources, usage_count: sources.length };
+}
+function firstOptional(ordered, key) {
+  const found = ordered.find((record) => record[key] !== undefined);
+  return found === undefined ? {} : { [key]: found[key] };
+}
+function collapse(group) {
+  const ordered = [...[...group.held].sort(byAge), ...[...group.incoming].sort(byAge)];
+  if (ordered.length === 1) {
+    return ordered[0];
+  }
+  const seen = new Set;
+  let weighted = 0;
+  for (const member of ordered) {
+    const own = sourcesOf(member);
+    const fresh = own.filter((source) => !seen.has(source));
+    const base = hundredths2(member.confidence) - STEP_H * (own.length - 1);
+    weighted += base * fresh.length;
+    for (const source of fresh) {
+      seen.add(source);
+    }
+  }
+  const sources = [...seen].sort();
+  const stepped = Math.round(weighted / sources.length + STEP_H * (sources.length - 1));
+  const confidence = Math.min(MAX_H, Math.max(MIN_H, stepped)) / HUNDREDTHS2;
+  const byAgeAll = [...ordered].sort(byAge);
+  const lead = byAgeAll[0];
+  const rest = {};
+  for (const [key, value] of Object.entries(lead)) {
+    if (key !== "artifact" && key !== "promoted_to") {
+      Object.assign(rest, { [key]: value });
+    }
+  }
+  return {
+    ...rest,
+    ...firstOptional(byAgeAll, "artifact"),
+    ...firstOptional(byAgeAll, "promoted_to"),
+    confidence,
+    usage_count: sources.length,
+    sources
+  };
+}
+function sameButStamp(left, right) {
+  const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
+  keys.delete("updated_at");
+  return [...keys].every((key) => {
+    const field = key;
+    return JSON.stringify(left[field]) === JSON.stringify(right[field]);
+  });
+}
+function stamp(record, held, now) {
+  const before = held.find((candidate) => candidate.id === record.id);
+  if (before !== undefined && sameButStamp(before, record)) {
+    return before;
+  }
+  return { ...record, updated_at: now };
+}
+function withStatus(record, status) {
+  return record.status === status ? record : { ...record, status };
+}
+function groupByAction(held, incoming) {
+  const groups = new Map;
+  const groupOf = (hash) => {
+    const found = groups.get(hash);
+    if (found !== undefined) {
+      return found;
+    }
+    const made = { held: [], incoming: [] };
+    groups.set(hash, made);
+    return made;
+  };
+  for (const record of held) {
+    groupOf(record.action_hash).held.push(record);
+  }
+  for (const record of incoming) {
+    groupOf(record.action_hash).incoming.push(record);
+  }
+  return groups;
+}
+function settleOne(hash, group, held, now) {
+  if (group.held.length === 0 && group.incoming.length === 1) {
+    return {
+      produced: [group.incoming[0]],
+      discarded: [],
+      rules: new Map([[hash, "new-trigger"]])
+    };
+  }
+  const record = stamp(withStatus(collapse(group), "active"), held, now);
+  return { produced: [record], discarded: [], rules: new Map([[hash, "same-action"]]) };
+}
+function settleMany(collapsed, held, now) {
+  const leaderH = Math.max(...[...collapsed.values()].map((record) => hundredths2(record.confidence)));
+  const kept = new Map;
+  const discarded = [];
+  for (const [hash, record] of collapsed) {
+    if (leaderH - hundredths2(record.confidence) > GAP_H) {
+      discarded.push(record);
+    } else {
+      kept.set(hash, record);
+    }
+  }
+  const status = kept.size > 1 ? "flagged" : "active";
+  const rule = kept.size > 1 ? "flagged" : "higher-confidence";
+  const rules = new Map;
+  for (const hash of collapsed.keys()) {
+    rules.set(hash, kept.has(hash) ? rule : "higher-confidence");
+  }
+  const produced = [...kept.values()].map((record) => stamp(withStatus(record, status), held, now));
+  return {
+    produced: produced.sort(byConfidence),
+    discarded: discarded.sort(byConfidence),
+    rules
+  };
+}
+function settleTrigger(held, incoming, now) {
+  const groups = groupByAction(held, incoming);
+  if (groups.size === 1) {
+    const [hash, group] = [...groups.entries()][0];
+    return settleOne(hash, group, held, now);
+  }
+  const collapsed = new Map;
+  for (const [hash, group] of groups) {
+    collapsed.set(hash, collapse(group));
+  }
+  return settleMany(collapsed, held, now);
+}
+function merge(held, payload, now) {
+  const incoming = payload.instincts.map((record) => withSource(record, payload.source_id));
+  const keys = [...new Set(incoming.map((record) => triggerKey(record.trigger)))];
+  const outcomes = new Map;
+  for (const key of keys) {
+    const onKey = (record) => triggerKey(record.trigger) === key;
+    outcomes.set(key, settleTrigger(held.filter(onKey), incoming.filter(onKey), now));
+  }
+  const decisions = payload.instincts.map((record) => {
+    const outcome = outcomes.get(triggerKey(record.trigger));
+    return {
+      incoming: record,
+      rule: outcome.rules.get(record.action_hash),
+      produced: [...outcome.produced]
+    };
+  });
+  return {
+    decisions,
+    discarded: keys.flatMap((key) => outcomes.get(key).discarded)
+  };
+}
+export { bless, promotable, merge };