@klhapp/skillmux 1.6.0 → 1.7.0

package/src/config-mutation.ts

@@ -1,65 +0,0 @@
-import { writeFileSync, renameSync } from "node:fs";
-
-export interface ThresholdsPatchOptions {
-  matchScore: number;
-  matchMargin: number;
-  candidateFloor: number;
-  runId: string;
-}
-
-/**
- * Remove a TOML section header and all lines until the next section header
- * (or end of file). Matches exact header string at start of line.
- */
-export function removeSectionBlock(source: string, header: string): string {
-  const lines = source.split("\n");
-  const out: string[] = [];
-  let skipping = false;
-  for (const line of lines) {
-    const trimmed = line.trimEnd();
-    if (trimmed === header || trimmed.startsWith(header + " ")) {
-      skipping = true;
-      continue;
-    }
-    if (skipping && line.trimStart().startsWith("[")) {
-      skipping = false;
-    }
-    if (!skipping) out.push(line);
-  }
-  return out.join("\n");
-}
-
-/**
- * Surgically patch a TOML string to set [inference.thresholds] values and
- * [inference.calibration] run_id while preserving unrelated sections and comments.
- */
-export function patchToml(
-  source: string,
-  opts: ThresholdsPatchOptions,
-): string {
-  const thresholdsBlock = `[inference.thresholds]\nmatch_score = ${opts.matchScore}\nmatch_margin = ${opts.matchMargin}\ncandidate_floor = ${opts.candidateFloor}\n`;
-  const calibrationBlock = `[inference.calibration]\nrun_id = "${opts.runId}"\n`;
-
-  // Remove any existing [inference.thresholds] and [inference.calibration] sections
-  let result = removeSectionBlock(source, "[inference.thresholds]");
-  result = removeSectionBlock(result, "[inference.calibration]");
-
-  // Append both sections cleanly
-  result = result.trimEnd() + "\n\n" + thresholdsBlock + "\n" + calibrationBlock;
-  return result;
-}
-
-/**
- * Atomically write patched TOML to disk via temp file write and renameSync.
- */
-export async function patchTomlFile(
-  tomlPath: string,
-  opts: ThresholdsPatchOptions,
-): Promise<void> {
-  const existing = await Bun.file(tomlPath).text();
-  const patched = patchToml(existing, opts);
-
-  const tmpPath = `${tomlPath}.${process.pid}.tmp`;
-  writeFileSync(tmpPath, patched);
-  renameSync(tmpPath, tomlPath);
-}

package/src/dataset-generator.ts

@@ -1,119 +0,0 @@
-import type { DecisionSplit, DecisionOutcome } from "./calibrate";
-import type { VaultSkill } from "./vault";
-
-export interface RawDecisionCase {
-  query: string;
-  split: DecisionSplit;
-  expected_outcome: DecisionOutcome;
-  relevant_skill_ids: string[];
-}
-
-export interface GenerateDatasetOptions {
-  /** Target number of queries per split. Default: 10. */
-  queriesPerSplit?: number;
-}
-
-const STOP_WORDS = new Set([
-  "a", "an", "and", "are", "as", "at", "be", "by", "for", "from", "in", "is",
-  "it", "of", "on", "or", "the", "this", "to", "use", "with",
-]);
-
-function words(value: string): string[] {
-  return value
-    .toLowerCase()
-    .match(/[a-z0-9]+/g)
-    ?.filter((word) => word.length > 2 && !STOP_WORDS.has(word)) ?? [];
-}
-
-function anchors(skill: VaultSkill): string[] {
-  const preferred = [...skill.aliases.flatMap(words), ...words(skill.title)];
-  const fallback = words(skill.description);
-  return [...new Set([...preferred, ...fallback])].slice(0, 2);
-}
-
-function matchedQuery(skill: VaultSkill, variant: number): string {
-  const [first = "specialized", second = "workflow"] = anchors(skill);
-  const templates = [
-    `I need practical guidance completing an unfamiliar ${first} ${second} task safely`,
-    `Which available workflow can handle my unusual ${first} ${second} problem end to end`,
-    `Please guide me through a difficult unfamiliar ${first} ${second} operation safely`,
-  ];
-  return templates[variant % templates.length]!;
-}
-
-function ambiguousQuery(first: VaultSkill, second: VaultSkill): string {
-  const [firstAnchor = "first"] = anchors(first);
-  const [secondAnchor = "second"] = anchors(second);
-  return `Help with a workflow spanning both ${firstAnchor} and ${secondAnchor} responsibilities`;
-}
-
-function nearMissQuery(first: VaultSkill, second: VaultSkill): string {
-  const [firstAnchor = "one"] = anchors(first);
-  const [secondAnchor = "another"] = anchors(second);
-  return `Explain the theory comparing ${firstAnchor} and ${secondAnchor} without performing either workflow`;
-}
-
-/**
- * Automatically generate a synthetic decision-policy calibration dataset
- * from local vault skill definitions. Runs 100% locally with zero data leaks.
- */
-export function generateDataset(
-  skills: VaultSkill[],
-  options: GenerateDatasetOptions = {},
-): RawDecisionCase[] {
-  if (skills.length < 4) {
-    throw new Error(
-      "Dataset generation requires at least 4 vault skills so tune and test can each contain matched and ambiguous cases without skill leakage",
-    );
-  }
-
-  const cases: RawDecisionCase[] = [];
-  const sorted = [...skills].sort((a, b) => a.skill_id.localeCompare(b.skill_id));
-  const splitAt = Math.ceil(sorted.length / 2);
-  const bySplit: Record<DecisionSplit, VaultSkill[]> = {
-    tune: sorted.slice(0, splitAt),
-    test: sorted.slice(splitAt),
-  };
-  const targetPerSplit = Math.max(3, options.queriesPerSplit ?? 10);
-
-  for (const split of ["tune", "test"] as const) {
-    const splitSkills = bySplit[split];
-    for (let i = 0; i < splitSkills.length; i++) {
-      const skill = splitSkills[i]!;
-      cases.push({
-        query: matchedQuery(skill, i),
-        split,
-        expected_outcome: "matched",
-        relevant_skill_ids: [skill.skill_id],
-      });
-    }
-
-    const first = splitSkills[0]!;
-    const second = splitSkills[1]!;
-    cases.push({
-      query: ambiguousQuery(first, second),
-      split,
-      expected_outcome: "ambiguous",
-      relevant_skill_ids: [first.skill_id, second.skill_id],
-    });
-    cases.push({
-      query: nearMissQuery(first, second),
-      split,
-      expected_outcome: "no_match",
-      relevant_skill_ids: [],
-    });
-
-    for (let i = cases.filter((item) => item.split === split).length; i < targetPerSplit; i++) {
-      const left = splitSkills[i % splitSkills.length]!;
-      const right = splitSkills[(i + 1) % splitSkills.length]!;
-      cases.push({
-        query: i % 2 === 0 ? matchedQuery(left, i) : nearMissQuery(left, right),
-        split,
-        expected_outcome: i % 2 === 0 ? "matched" : "no_match",
-        relevant_skill_ids: i % 2 === 0 ? [left.skill_id] : [],
-      });
-    }
-  }
-
-  return cases;
-}

package/src/decision.ts

@@ -1,45 +0,0 @@
-import type { RankedCandidate, Thresholds } from "./types";
-
-export interface DecisionInput {
-  reranked: boolean;
-  candidates: RankedCandidate[];
-  thresholds: Thresholds;
-}
-
-export type Decision =
-  | { outcome: "matched"; skill_id: string; score: number; margin: number }
-  | { outcome: "ambiguous"; candidates: RankedCandidate[] }
-  | { outcome: "no_match" };
-
-export function decideResolveOutcome({ reranked, candidates, thresholds }: DecisionInput): Decision {
-  if (candidates.length === 0) return { outcome: "no_match" };
-
-  // Degraded lane: no comparable scores exist, so never match; the (BM25-ordered)
-  // Without calibrated reranker scores, the shortlist goes to the calling LLM.
-  if (!reranked) return { outcome: "ambiguous", candidates: candidates.slice(0, thresholds.candidate_limit) };
-
-  if (
-    thresholds.match_score === undefined
-    || thresholds.match_margin === undefined
-    || thresholds.candidate_floor === undefined
-  ) {
-    return {
-      outcome: "ambiguous",
-      candidates: candidates.slice(0, thresholds.candidate_limit),
-    };
-  }
-  const { match_score, match_margin, candidate_floor } = thresholds;
-
-  const sorted = [...candidates].sort((a, b) => (b.score ?? -Infinity) - (a.score ?? -Infinity));
-  const eligible = sorted.filter((c) => (c.score ?? -Infinity) >= candidate_floor);
-  if (eligible.length === 0) return { outcome: "no_match" };
-
-  const top = eligible[0]!;
-  const topScore = top.score!;
-  const margin = sorted.length === 1 ? topScore : topScore - (sorted[1]!.score ?? 0);
-
-  if (topScore >= match_score && margin >= match_margin) {
-    return { outcome: "matched", skill_id: top.skill_id, score: topScore, margin };
-  }
-  return { outcome: "ambiguous", candidates: eligible.slice(0, thresholds.candidate_limit) };
-}