@saasontools/strauss-kb 0.1.18 → 0.1.20

package/dist/index.js

@@ -1,10 +1,10 @@
 import {
   runKbCli
-} from "./chunk-IOIUS26S.js";
+} from "./chunk-XDH6J6CH.js";
 import {
   createKbMcpServer,
   runKbMcpServer
-} from "./chunk-ROGVYSMV.js";
+} from "./chunk-EXZQZJU2.js";
 import {
   BaseError,
   CONTEXT_BEGIN,
@@ -16,12 +16,14 @@ import {
   DEFAULT_LOAD_BUDGET,
   DEFAULT_PACK_HOPS,
   DEFAULT_PACK_MAX_NODES,
+  DEFAULT_THRESHOLDS,
   DEFAULT_TYPED_LINK_RELS,
   DEFAULT_UNVERIFIED_DAYS,
   ErrorTypes,
   Fault,
   INDEX_FILE,
   KB_CAUSAL_LINK_RELS,
+  KB_CLASSES,
   KB_COMMANDS,
   KB_COMMANDS_BY_NAME,
   KB_CONCEPT_ID_PATTERN,
@@ -35,10 +37,15 @@ import {
   KB_RECORD_TYPES,
   KB_SLUG_PATTERN,
   KbBaseFrozenError,
+  KbClassifyInputError,
   KbInvalidConceptIdError,
   KbMissingFlagValueError,
   KbPackBudgetExceededError,
   KbPinsMalformedError,
+  KbPromoteCollisionError,
+  KbPromoteSelfError,
+  KbPromoteStandingError,
+  KbPromoteStoppedError,
   KbRecordAlreadyExistsError,
   KbRecordNotFoundError,
   KbSelfVerificationError,
@@ -51,16 +58,20 @@ import {
   PINS_FILE,
   PINS_LOCAL_FILE,
   PIN_LAYERS,
+  PROMOTION_SOURCE_ID,
   RECORD_TYPES,
   SEARCH_INDEX_FILE,
   TRACE_EDGES,
   TreeSitterResolver,
   adjudicate,
   anchorFilePath,
+  anchorOnHunk,
   assertBaseNotFrozen,
   backlinks,
   buildContext,
+  carry,
   catalog,
+  classifyDiff,
   classifyDrift,
   composeDecisionRecord,
   composeInputSchema,
@@ -85,8 +96,11 @@ import {
   isKbLinkRel,
   isKbRecordType,
   isNoDecisionRecord,
+  isReviewTag,
   kbActorStampSchema,
   kbAnchorSchema,
+  kbAnchorSpanSchema,
+  kbAnchorWriteSchema,
   kbConceptIdSchema,
   kbJsonSchemas,
   kbLinkSchema,
@@ -97,6 +111,8 @@ import {
   languageForFile,
   listPins,
   loadQmd,
+  matchToDiff,
+  matchesTags,
   mergedContextBudgets,
   neighbours,
   pack,
@@ -104,6 +120,8 @@ import {
   parseMarkdownWithFrontmatter,
   pinBase,
   prepareResolvers,
+  promoteCandidates,
+  promoteInputSchema,
   readMergedPins,
   readPinsLayer,
   readRemoteAnchors,
@@ -123,6 +141,7 @@ import {
   selectDecisions,
   splitMarkdownFrontmatter,
   stringifyMarkdownWithFrontmatter,
+  symbolRangeIndex,
   syncInstructions,
   toHookJson,
   trace,
@@ -130,87 +149,7 @@ import {
   unifiedDiff,
   unpinBase,
   validateBundle
-} from "./chunk-GSOTMWZZ.js";
-
-// src/match-diff.ts
-function matchToDiff(files, records, options = {}) {
-  const ranges = indexRanges(options.symbolRanges ?? []);
-  const anchored = records.filter(
-    (record) => (record.frontmatter.strauss_anchors ?? []).length > 0
-  );
-  const matches = [];
-  for (const file of files) {
-    const candidates = anchored.map((record) => ({
-      record,
-      anchors: (record.frontmatter.strauss_anchors ?? []).filter(
-        (anchor) => normalize(anchor.file) === normalize(file.filePath)
-      )
-    })).filter(({ anchors }) => anchors.length > 0);
-    if (!candidates.length) continue;
-    for (const hunk of file.hunks) {
-      const hits = [];
-      let precision = "symbol";
-      for (const { record, anchors } of candidates) {
-        const placement = place(anchors, file.filePath, hunk, ranges);
-        if (placement === "miss") continue;
-        if (placement === "file") precision = "file";
-        hits.push(record);
-      }
-      if (!hits.length) continue;
-      matches.push({
-        filePath: file.filePath,
-        hunk,
-        records: order(adjudicate(hits, records, options.now)),
-        precision
-      });
-    }
-  }
-  return matches;
-}
-function place(anchors, filePath, hunk, ranges) {
-  let fallback = "miss";
-  for (const anchor of anchors) {
-    if (!anchor.symbol) return "file";
-    const resolved = ranges.get(key(filePath, anchor.symbol));
-    if (!resolved?.length) {
-      fallback = "file";
-      continue;
-    }
-    if (resolved.some((range) => overlaps(range, hunk))) return "symbol";
-  }
-  return fallback;
-}
-function overlaps(range, hunk) {
-  return range.startLine <= hunk.endLine && hunk.startLine <= range.endLine;
-}
-function order(records) {
-  const rank = {
-    current: 0,
-    unsettled: 1,
-    open: 2,
-    superseded: 3,
-    rejected: 4
-  };
-  return [...records].sort(
-    (left, right) => (rank[left.standing] ?? 9) - (rank[right.standing] ?? 9) || (left.record.frontmatter.generated?.at ?? "").localeCompare(
-      right.record.frontmatter.generated?.at ?? ""
-    )
-  );
-}
-function indexRanges(ranges) {
-  const byKey = /* @__PURE__ */ new Map();
-  for (const range of ranges) {
-    const id = key(range.file, range.symbol);
-    byKey.set(id, [...byKey.get(id) ?? [], range]);
-  }
-  return byKey;
-}
-function key(file, symbol) {
-  return `${normalize(file)}#${symbol}`;
-}
-function normalize(path) {
-  return path.replace(/^\.\//, "");
-}
+} from "./chunk-QQLPJO4R.js";
 export {
   BaseError,
   CONTEXT_BEGIN,
@@ -222,12 +161,14 @@ export {
   DEFAULT_LOAD_BUDGET,
   DEFAULT_PACK_HOPS,
   DEFAULT_PACK_MAX_NODES,
+  DEFAULT_THRESHOLDS,
   DEFAULT_TYPED_LINK_RELS,
   DEFAULT_UNVERIFIED_DAYS,
   ErrorTypes,
   Fault,
   INDEX_FILE,
   KB_CAUSAL_LINK_RELS,
+  KB_CLASSES,
   KB_COMMANDS,
   KB_COMMANDS_BY_NAME,
   KB_CONCEPT_ID_PATTERN,
@@ -241,10 +182,15 @@ export {
   KB_RECORD_TYPES,
   KB_SLUG_PATTERN,
   KbBaseFrozenError,
+  KbClassifyInputError,
   KbInvalidConceptIdError,
   KbMissingFlagValueError,
   KbPackBudgetExceededError,
   KbPinsMalformedError,
+  KbPromoteCollisionError,
+  KbPromoteSelfError,
+  KbPromoteStandingError,
+  KbPromoteStoppedError,
   KbRecordAlreadyExistsError,
   KbRecordNotFoundError,
   KbSelfVerificationError,
@@ -257,16 +203,20 @@ export {
   PINS_FILE,
   PINS_LOCAL_FILE,
   PIN_LAYERS,
+  PROMOTION_SOURCE_ID,
   RECORD_TYPES,
   SEARCH_INDEX_FILE,
   TRACE_EDGES,
   TreeSitterResolver,
   adjudicate,
   anchorFilePath,
+  anchorOnHunk,
   assertBaseNotFrozen,
   backlinks,
   buildContext,
+  carry,
   catalog,
+  classifyDiff,
   classifyDrift,
   composeDecisionRecord,
   composeInputSchema,
@@ -292,8 +242,11 @@ export {
   isKbLinkRel,
   isKbRecordType,
   isNoDecisionRecord,
+  isReviewTag,
   kbActorStampSchema,
   kbAnchorSchema,
+  kbAnchorSpanSchema,
+  kbAnchorWriteSchema,
   kbConceptIdSchema,
   kbJsonSchemas,
   kbLinkSchema,
@@ -305,6 +258,7 @@ export {
   listPins,
   loadQmd,
   matchToDiff,
+  matchesTags,
   mergedContextBudgets,
   neighbours,
   pack,
@@ -312,6 +266,8 @@ export {
   parseMarkdownWithFrontmatter,
   pinBase,
   prepareResolvers,
+  promoteCandidates,
+  promoteInputSchema,
   readMergedPins,
   readPinsLayer,
   readRemoteAnchors,
@@ -333,6 +289,7 @@ export {
   selectDecisions,
   splitMarkdownFrontmatter,
   stringifyMarkdownWithFrontmatter,
+  symbolRangeIndex,
   syncInstructions,
   toHookJson,
   trace,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/match-diff.ts"],"sourcesContent":["import { adjudicate, type KbAdjudicated } from \"./adjudicate.js\";\nimport type { KbAnchor, KbRecord } from \"./kb-record.schema.js\";\n\n/**\n * Which records apply to which part of a change.\n *\n * Takes a structural description of a diff rather than a patch, so this package\n * carries no diff parser: callers already have one, and a knowledge base has no\n * business preferring a particular flavour of unified diff.\n *\n * Deterministic on purpose. Every step here is mechanical — the one judgment,\n * whether a matched record is worth showing a reviewer, is deliberately absent.\n * A model placed here would sit between the reviewer and their diff on every\n * review, to answer a question nobody has yet shown needs asking.\n *\n * Distinct from `load()`, which hands a reader the whole base. That answers\n * \"does anything address this question\"; this answers \"what is attached to this\n * code\", and an anchor is the author's own statement rather than an inference\n * from one. A reader guessing which record relates to a hunk would be guessing\n * at something already written down — and a diff has dozens of hunks, which is\n * dozens of reader calls against microseconds of matching. Where they compose:\n * this narrows a hunk to a few records, and a reader asked to explain them gets\n * those, not the base.\n */\nexport type DiffHunk = {\n  /** 1-based, inclusive, in the file's post-change line numbering. */\n  startLine: number;\n  endLine: number;\n};\n\nexport type DiffFile = {\n  /** Repo-relative, matching how anchors are written. */\n  filePath: string;\n  hunks: DiffHunk[];\n};\n\n/**\n * A symbol resolved to lines. Supplied by whatever the caller uses to index\n * symbols; absence is tolerated — see `place()`.\n */\nexport type SymbolRange = {\n  file: string;\n  symbol: string;\n  startLine: number;\n  endLine: number;\n};\n\nexport type DiffMatch = {\n  filePath: string;\n  hunk: DiffHunk;\n  /** Current records first — what still holds should be read before what does not. */\n  records: KbAdjudicated[];\n  /**\n   * `symbol` when every record here was placed by a resolved symbol range,\n   * `file` when at least one fell back to the whole file. Reported rather than\n   * hidden: a caller showing a file-level match as though it were pinned to\n   * these lines is claiming a precision it does not have.\n   */\n  precision: \"symbol\" | \"file\";\n};\n\nexport type MatchOptions = {\n  /** Without these, symbol anchors degrade to file level rather than vanishing. */\n  symbolRanges?: SymbolRange[];\n  now?: Date;\n};\n\nexport function matchToDiff(\n  files: DiffFile[],\n  records: KbRecord[],\n  options: MatchOptions = {},\n): DiffMatch[] {\n  const ranges = indexRanges(options.symbolRanges ?? []);\n  const anchored = records.filter(\n    (record) => (record.frontmatter.strauss_anchors ?? []).length > 0,\n  );\n  const matches: DiffMatch[] = [];\n\n  for (const file of files) {\n    const candidates = anchored\n      .map((record) => ({\n        record,\n        anchors: (record.frontmatter.strauss_anchors ?? []).filter(\n          (anchor) => normalize(anchor.file) === normalize(file.filePath),\n        ),\n      }))\n      .filter(({ anchors }) => anchors.length > 0);\n    if (!candidates.length) continue;\n\n    for (const hunk of file.hunks) {\n      const hits: KbRecord[] = [];\n      let precision: DiffMatch[\"precision\"] = \"symbol\";\n\n      for (const { record, anchors } of candidates) {\n        const placement = place(anchors, file.filePath, hunk, ranges);\n        if (placement === \"miss\") continue;\n        if (placement === \"file\") precision = \"file\";\n        hits.push(record);\n      }\n\n      if (!hits.length) continue;\n      matches.push({\n        filePath: file.filePath,\n        hunk,\n        records: order(adjudicate(hits, records, options.now)),\n        precision,\n      });\n    }\n  }\n\n  return matches;\n}\n\n/**\n * Whether any of a record's anchors puts it on this hunk.\n *\n * An anchor naming only a file is about the whole file, so it lands on every\n * hunk in it. One naming a symbol lands only where that symbol's lines overlap\n * — unless nothing resolved the symbol, in which case it falls back to the file\n * rather than disappearing. A record silently absent because a resolver was\n * unavailable is worse than one shown imprecisely and labelled as such.\n */\nfunction place(\n  anchors: KbAnchor[],\n  filePath: string,\n  hunk: DiffHunk,\n  ranges: Map<string, SymbolRange[]>,\n): \"symbol\" | \"file\" | \"miss\" {\n  let fallback: \"file\" | \"miss\" = \"miss\";\n\n  for (const anchor of anchors) {\n    if (!anchor.symbol) return \"file\";\n\n    const resolved = ranges.get(key(filePath, anchor.symbol));\n    if (!resolved?.length) {\n      fallback = \"file\";\n      continue;\n    }\n    if (resolved.some((range) => overlaps(range, hunk))) return \"symbol\";\n  }\n\n  return fallback;\n}\n\nfunction overlaps(range: SymbolRange, hunk: DiffHunk): boolean {\n  return range.startLine <= hunk.endLine && hunk.startLine <= range.endLine;\n}\n\n/** Current before superseded, then oldest first, so an arc reads in order. */\nfunction order(records: KbAdjudicated[]): KbAdjudicated[] {\n  const rank: Record<string, number> = {\n    current: 0,\n    unsettled: 1,\n    open: 2,\n    superseded: 3,\n    rejected: 4,\n  };\n  return [...records].sort(\n    (left, right) =>\n      (rank[left.standing] ?? 9) - (rank[right.standing] ?? 9) ||\n      (left.record.frontmatter.generated?.at ?? \"\").localeCompare(\n        right.record.frontmatter.generated?.at ?? \"\",\n      ),\n  );\n}\n\nfunction indexRanges(ranges: SymbolRange[]): Map<string, SymbolRange[]> {\n  const byKey = new Map<string, SymbolRange[]>();\n  for (const range of ranges) {\n    const id = key(range.file, range.symbol);\n    byKey.set(id, [...(byKey.get(id) ?? []), range]);\n  }\n  return byKey;\n}\n\nfunction key(file: string, symbol: string): string {\n  return `${normalize(file)}#${symbol}`;\n}\n\n/** Anchors are written by hand often enough that `./` shows up. */\nfunction normalize(path: string): string {\n  return path.replace(/^\\.\\//, \"\");\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}