@saasontools/strauss-kb 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Assaf Kamil
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,340 @@
+# @saasontools/strauss-kb
+
+A knowledge base is a directory of small markdown records. Copy the directory
+and you have the whole thing — nothing outside it is needed to read, search,
+adjudicate, or trace it.
+
+This package is that directory's library, its command line, and its MCP server.
+All three project one command table, so a capability exists in every surface or
+in none.
+
+The point of the format is **standing**, not storage. A search engine answers
+"does this match?"; a knowledge base also has to answer "is this still what we
+hold?" — and the two disagree in a predictable direction, because a superseded
+record is usually the older, longer, more general one and its replacement is
+usually a narrowing. Every result therefore arrives flagged rather than
+filtered.
+
+## Install
+
+```bash
+npm install -g @saasontools/strauss-kb
+```
+
+Global install is the supported path. The consumers of the CLI are agent skills
+that shell out to `strauss-kb` by name, many times per session and from whatever
+directory the work happens to be in — so the binary has to be on `PATH` without
+a per-project setup step, and per-call resolution latency is paid on every call.
+The trade-off accepted is that the version is machine-wide and not pinned by the
+consuming project; the on-disk format is the compatibility contract, and the
+reader is deliberately tolerant of records it did not write (unknown frontmatter
+keys are preserved, a missing status defaults).
+
+Two alternatives work and are not the documented convention:
+
+|                | Command                                                           | When it fits                                                                                                                                    |
+| -------------- | ----------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
+| Per invocation | `npx -y @saasontools/strauss-kb@0.1`                              | Pinned and zero-install; adds resolution latency to every call and needs a warm npx cache or a network.                                         |
+| Project-local  | `pnpm add -D @saasontools/strauss-kb` then `pnpm exec strauss-kb` | Pinned per repository and offline after install; bare `strauss-kb` does not resolve outside that repository, so skills cannot use one spelling. |
+
+As a library:
+
+```bash
+npm install @saasontools/strauss-kb
+```
+
+Ships ESM and CommonJS. A consumer that transpiles per-file to CommonJS without
+bundling can `require()` it without depending on its Node version honouring
+`require(esm)`.
+
+## What is in a base
+
+```
+<kb>/
+  <type>.<slug>.md    records
+  INDEX.md            index      derived, store-owned
+  log.jsonl           history    primary, append-only
+  .index.sqlite       search     derived, gitignored
+```
+
+The default base is `.strauss/kb` relative to the working directory;
+`--bundle PATH` addresses any other. A scratch base under a worktree and a
+committed base versioned beside the code it describes are the same format with
+different lifetimes. Nothing promotes one to the other.
+
+`INDEX.md` and `log.jsonl` are store-owned and differ in kind — treating them
+alike is how the history gets lost:
+
+|         | `INDEX.md`                                 | `log.jsonl`                                 |
+| ------- | ------------------------------------------ | ------------------------------------------- |
+| Nature  | derived — recomputable from frontmatter    | primary — records events nothing else holds |
+| Write   | full regenerate                            | append                                      |
+| Repair  | rebuilt when it disagrees with the records | malformed lines reported, never rewritten   |
+| If lost | reconstructed free                         | gone                                        |
+
+Repair-on-read, not coordination, is what lets both exist without a lock. The
+index is _eventually_ correct: a writer whose scan predated another's record
+publishes a briefly stale index, and the next read through the store settles it.
+
+## Records
+
+The filename is the identity. `fact.auth-retries.md` has concept id
+`fact.auth-retries` — `<type>.<slug>`, both halves kebab-case. One record per
+file, so parallel writers never merge; they only choose distinct names.
+
+Records are [OKF](https://github.com/GoogleCloudPlatform/knowledge-catalog)
+concepts. `type` is the only key OKF requires; `title`, `description`,
+`resource`, `tags`, `sources`, `generated`, `verified`, and `stale_after` are
+OKF's. Unknown keys are preserved rather than stripped, as OKF requires of
+consumers.
+
+Anything prefixed `strauss_` is this package's extension, namespaced so a later
+OKF version defining the same name cannot collide:
+
+| Key                                                            | Meaning                                                                                                                                    |
+| -------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| `strauss_status`                                               | `draft`, `proposed`, `accepted`, `open`, `resolved`, `rejected`, `superseded`. Parses with a default of `draft`.                           |
+| `strauss_supersedes` / `strauss_superseded_by`                 | Both directions of a supersession, written together.                                                                                       |
+| `strauss_anchors`                                              | `{ file, symbol? }` — where the record attaches in the code. Symbolic, because a line number written mid-change is wrong by the end of it. |
+| `strauss_assumption`                                           | The claim has no source, said as a field rather than as a fake entry in `sources`.                                                         |
+| `strauss_answered`                                             | Who resolved an open question, and when.                                                                                                   |
+| `strauss_verify`                                               | Checks that would confirm the record still holds.                                                                                          |
+| `strauss_materiality` / `strauss_confidence` / `strauss_owner` | `blocking`/`important`/`non-blocking`, `low`/`medium`/`high`, and a name.                                                                  |
+
+Edges are markdown links in the body, as OKF specifies — untyped, with the kind
+conveyed by the surrounding prose. Broken links are legal: records are routinely
+written before the ones they point at exist.
+
+Twelve record types differ only in what their body answers and where they start
+in the lifecycle — `fact`, `requirement`, `constraint`, `decision`,
+`assumption`, `open-question`, `risk`, `contract`, `flow`, `affected-system`,
+`test-obligation`, `source-note`. `strauss-kb types` prints each one's purpose,
+body sections, and initial status; a section a type does not define is rejected
+rather than written.
+
+Do not work from memory on the frontmatter contract — `strauss-kb schema` emits
+JSON Schema generated from the code that enforces it, so it cannot drift from
+what a write will accept.
+
+```yaml
+---
+type: decision
+title: Compare-and-swap rather than a lock
+description: A stale lock hold blocks every later writer.
+generated: { by: agent, at: 2026-08-16T09:14:00Z }
+verified: []
+strauss_status: accepted
+strauss_anchors:
+  - { file: src/kb-store.ts, symbol: KbStore.setStatus }
+---
+
+## Decision
+
+Read-modify-write checks a content digest immediately before publishing.
+
+## Rejected
+
+A lock file. It closes the window and adds a stale-hold failure mode that is
+worse than the residue.
+```
+
+## Writes
+
+Records are staged to a sibling file and published atomically, so a concurrent
+reader sees a whole record or none. Publication uses `link`, which fails when
+the name is taken — two writers choosing one concept id is a 409 the caller must
+answer, by picking a more specific slug or by saying it meant to replace.
+`rename` is used only when the caller passes `overwrite`.
+
+`supersede` writes both directions, so a backlink cannot drift in normal use and
+`validate` drops to catching hand-edits.
+
+Records are never deleted. Superseding keeps the earlier reasoning inspectable,
+which is what a later `trace` reads.
+
+## CLI
+
+```
+strauss-kb [--bundle PATH] <command> [args]
+
+  write <type> < record.json               Write one record.
+  write-decision < decision.json           Write a decision, with the rejected alternative as a field.
+  no-decision <reason...>                  Claim in one sentence that there was nothing to decide.
+  status <concept-id> <status>             Move a record's status, compare-and-swap.
+  supersede <concept-id> <replacement-id>  Mark a record superseded, linking both directions.
+  answer <concept-id> <answer...>          Resolve an open question and append the answer.
+  load [type] [--budget N]                 Hand over the whole base, each record with its standing.
+  query <text...>                          Search; every match arrives flagged with its standing.
+  trace <concept-id> [edges...]            How a position was arrived at, as a timeline.
+  list [type]                              Every record, optionally narrowed to one type.
+  index                                    The index, rebuilt if it disagrees with the records.
+  log                                      What touched what, and when.
+  validate                                 Cross-record checks. Exits 1 when it reports a problem.
+  schema                                   JSON Schema for the format.
+  types                                    The twelve types, their sections and initial status.
+
+  --bundle PATH  defaults to ./.strauss/kb
+  STRAUSS_KB_ACTOR names the writer in the log
+```
+
+Results go to stdout as JSON — `index` is markdown, which is what it is. Errors
+go to stderr and exit 1. `validate` is the one command whose exit code is not
+just "did it run": a check that reports a problem succeeded as a command and
+failed as a check, so it exits 1 with its findings on stdout.
+
+```bash
+strauss-kb --bundle .strauss/kb write fact <<'JSON'
+{
+  "slug": "cache-key-includes-region",
+  "title": "The cache key includes the region",
+  "why": "A region-less key serves one region another region's data.",
+  "sections": { "Claim": "Every key is prefixed with the region." },
+  "anchors": [{ "file": "src/cache/order-cache.ts", "symbol": "OrderCache.get" }]
+}
+JSON
+
+strauss-kb query cache key region
+strauss-kb validate || echo "problems above"
+```
+
+## MCP server
+
+`strauss-kb-mcp` speaks stdio and takes no API key and no required environment.
+Every CLI verb is a tool: `kb_write`, `kb_write_decision`, `kb_no_decision`,
+`kb_status`, `kb_supersede`, `kb_answer`, `kb_load`, `kb_query`, `kb_trace`,
+`kb_list`, `kb_index`, `kb_log`, `kb_validate`, `kb_schema`, `kb_types`. Every
+tool but `kb_schema` and `kb_types` takes a `bundlePath`; those two describe the
+format rather than any one base.
+
+```json
+{
+  "mcpServers": {
+    "strauss-kb": { "command": "strauss-kb-mcp" }
+  }
+}
+```
+
+The tool descriptions carry the judgment a schema cannot: that an unsourced
+claim is an `assumption` and not a `fact` with a vague source, that a conflict
+between two records belongs in a `risk` or a superseding `decision` rather than
+being quietly resolved, and that `kb_load` is usually the right first call.
+
+`STRAUSS_KB_ACTOR` names the writer in the log. Diagnostics go to stderr,
+because stdout is the JSON-RPC transport.
+
+## Library
+
+```ts
+import { KbStore, composeRecord, matchToDiff } from "@saasontools/strauss-kb";
+
+const store = new KbStore();
+await store.write(
+  ".strauss/kb",
+  composeRecord("decision", input, "agent", new Date().toISOString()),
+);
+
+const hits = await store.query(".strauss/kb", "cache key");
+for (const hit of hits) {
+  hit.standing; // current | superseded | rejected | unsettled | open
+  hit.heads; // where the supersession chain ends
+  hit.warnings; // rejected, broken-chain, forked-chain, stale, unverified…
+}
+```
+
+`matchToDiff` answers a different question from `query`: given a structural
+description of a diff, which records are anchored to each hunk. It takes hunks
+and optional symbol ranges rather than a patch, so this package carries no diff
+parser, and it degrades to file-level precision — labelled as such — when a
+symbol cannot be resolved.
+
+## Retrieval
+
+Three axes decide whether a record answers a question, and only one is a search
+problem:
+
+| Axis      | Source                                                  | Question                        |
+| --------- | ------------------------------------------------------- | ------------------------------- |
+| Relevance | BM25 where an index exists, substring where it does not | does this match?                |
+| Standing  | `strauss_status`, the supersession chain                | is this still what we hold?     |
+| Freshness | `stale_after`, `verified[]`                             | has anyone confirmed it lately? |
+
+**Load before you search.** These bases run to a few thousand tokens — twenty
+records measured at about 3,000 — so the first thing to try is taking all of it.
+On nine questions whose wording appears in no record, a reader holding the whole
+base answered eight; embedding search over the same records answered four. Two
+of those differences are structural rather than matters of degree: a reader can
+say no record answers the question, where vector search returns its nearest
+neighbour whatever the distance; and a reader picks the record that answers the
+question rather than the one nearest the topic.
+
+`load` refuses rather than truncating when a base exceeds its budget (25,000
+tokens by default). A truncated base is indistinguishable from a complete one,
+so a caller would answer "that was never decided" from a slice it did not know
+was a slice. Superseded records come back as name, replacement and date only —
+their bodies no longer hold, and a body read later in a long session outlives
+the qualifier that said so. `trace` still reaches them by id.
+
+**Flag, never filter.** `query` returns every hit with its standing, because a
+filtered result set is invisible — the caller cannot tell it missed anything.
+The single exception is narrow: a superseded record is dropped only when its
+replacement is also in the results, so the thread is never lost.
+
+**Trace inverts the point query.** In a query a `rejected` record is the most
+dangerous thing retrievable — a well-formed assertion of what someone decided
+_not_ to do. In a history it is the content. `trace` follows supersession,
+shared code anchors, and shared sources, and orders by `generated.at`; ranking a
+history is meaningless when the sequence is the point.
+
+Chain resolution happens on read. A stored head would need rewriting on every
+ancestor whenever a chain grows, which is derived state that goes stale. The
+walk follows both pointers, so a hand-edit that left one side behind cannot
+return a record the base openly claims is replaced. A cycle terminates with
+`chain-cycle`; a fork reports every head rather than presenting a guess as a
+fact; a missing replacement is `broken-chain` with no head — the case that needs
+the most care, because returning the stale record unmarked looks exactly like
+success.
+
+## Optional search tier
+
+`@tobilu/qmd` is an **optional peer dependency** providing BM25 (`searchLex`,
+no model download) over a `.index.sqlite` per base, rebuilt when a record is
+newer than the index.
+
+```bash
+npm install -g @tobilu/qmd    # alongside a global strauss-kb
+```
+
+With it absent — the default — `query` falls back to a substring scan over
+concept ids, titles, descriptions, and bodies. Nothing throws, no answer changes
+shape, and only recall degrades. Measured against that fallback on a
+twenty-record base, the lexical tier wins on word forms (`pages` finds a record
+saying only `page`) and on little else: eight of nine probe queries returned
+exactly what substring returned.
+
+The vector tier is deliberately off. It does close the semantic gap — "why not
+just use a mutex" finds a record about compare-and-swap that no lexical match
+can — but its scores do not separate right from wrong. A wrong hit scored 0.318
+against a correct one at 0.295, and any threshold that drops the first drops the
+second. Scores are evidence for a reader to weigh, not a filter to apply before
+one.
+
+qmd is used as a library, never through its own MCP server: that would let a
+caller reach a base without going through the store, and its default markdown
+glob returns `INDEX.md` as a search hit.
+
+## Constraints worth knowing
+
+**The store is the sole accessor, not merely the sole writer.** Excluding
+store-owned files from listings and repairing the index on read hold only while
+everything goes through one door. Reading one record by a concept id you already
+hold is the exception — no invariant, deterministic path.
+
+**Cross-base questions are unaskable.** Supersession, traces, and search stop at
+the directory boundary. "Was this settled somewhere else?" is answered by a
+person choosing which base to open. That is the price of a base that can be
+copied, deleted, or handed over whole, and it is what keeps the search index
+disposable.
+
+## License
+
+MIT

package/dist/chunk-KGM34MYU.js

@@ -0,0 +1,93 @@
+import {
+  KB_COMMANDS,
+  KB_COMMANDS_BY_NAME,
+  KB_DIR,
+  KbStore
+} from "./chunk-ZSYSHJVZ.js";
+
+// src/cli.ts
+import { join } from "path";
+async function runKbCli(argv) {
+  const { bundle, rest } = takeBundle(argv);
+  const name = rest[0] ?? "";
+  if (!name || name === "-h" || name === "--help") {
+    process.stdout.write(usage());
+    return;
+  }
+  const command = KB_COMMANDS_BY_NAME.get(name);
+  if (!command) die(`unknown command ${name}`);
+  const raw = await command.fromArgv(rest, bundle, readStdin);
+  const parsed = command.input.safeParse(raw);
+  if (!parsed.success) {
+    die(
+      `${name}: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ")}`
+    );
+  }
+  const store = new KbStore({
+    warn: (entry) => process.stderr.write(`${JSON.stringify(entry)}
+`)
+  });
+  const result = await command.run(
+    {
+      store,
+      actor: process.env.STRAUSS_KB_ACTOR ?? "unknown",
+      now: () => (/* @__PURE__ */ new Date()).toISOString()
+    },
+    parsed.data
+  );
+  if (command.failsWhen?.(result)) process.exitCode = 1;
+  process.stdout.write(
+    typeof result === "string" ? result.endsWith("\n") ? result : `${result}
+` : `${JSON.stringify(result, null, 2)}
+`
+  );
+}
+function takeBundle(argv) {
+  const at = argv.indexOf("--bundle");
+  if (at === -1) {
+    return { bundle: join(process.cwd(), KB_DIR), rest: argv };
+  }
+  const bundle = argv[at + 1];
+  if (!bundle) die("--bundle requires a path");
+  return { bundle, rest: [...argv.slice(0, at), ...argv.slice(at + 2)] };
+}
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let text = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => text += chunk);
+    process.stdin.on("end", () => resolve(text));
+    process.stdin.on("error", reject);
+  });
+}
+function die(message) {
+  process.stderr.write(`strauss-kb: error: ${message}
+`);
+  process.exit(1);
+}
+function summarise(description) {
+  const first = description.split("\n")[0] ?? "";
+  const sentence = first.includes(". ") ? `${first.slice(0, first.indexOf(". "))}.` : first;
+  return sentence.length > 78 ? `${sentence.slice(0, 75)}\u2026` : sentence;
+}
+function usage() {
+  const width = Math.max(...KB_COMMANDS.map((command) => command.usage.length));
+  return [
+    "strauss-kb \u2014 knowledge base commands",
+    "",
+    "Usage: strauss-kb [--bundle PATH] <command> [args]",
+    "",
+    ...KB_COMMANDS.map(
+      (command) => `  ${command.usage.padEnd(width)}  ${summarise(command.description)}`
+    ),
+    "",
+    `  --bundle PATH  defaults to ./${KB_DIR}`,
+    "  STRAUSS_KB_ACTOR names the writer in the log",
+    ""
+  ].join("\n");
+}
+
+export {
+  runKbCli
+};
+//# sourceMappingURL=chunk-KGM34MYU.js.map

package/dist/chunk-KGM34MYU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli.ts"],"sourcesContent":["/**\n * strauss-kb — a knowledge base's command line.\n *\n * A dispatcher over `KB_COMMANDS`, which the MCP server also projects. Nothing\n * command-specific lives here beyond turning argv into the object both\n * surfaces pass.\n */\nimport { join } from \"node:path\";\nimport { KB_COMMANDS, KB_COMMANDS_BY_NAME } from \"./commands.js\";\nimport { KB_DIR, KbStore } from \"./kb-store.js\";\n\nexport async function runKbCli(argv: string[]): Promise<void> {\n  const { bundle, rest } = takeBundle(argv);\n  const name = rest[0] ?? \"\";\n\n  if (!name || name === \"-h\" || name === \"--help\") {\n    process.stdout.write(usage());\n    return;\n  }\n\n  const command = KB_COMMANDS_BY_NAME.get(name);\n  if (!command) die(`unknown command ${name}`);\n\n  const raw = await command.fromArgv(rest, bundle, readStdin);\n  const parsed = command.input.safeParse(raw);\n  if (!parsed.success) {\n    die(\n      `${name}: ${parsed.error.issues\n        .map((issue) => `${issue.path.join(\".\") || \"(root)\"}: ${issue.message}`)\n        .join(\"; \")}`,\n    );\n  }\n\n  const store = new KbStore({\n    warn: (entry) => process.stderr.write(`${JSON.stringify(entry)}\\n`),\n  });\n  const result = await command.run(\n    {\n      store,\n      actor: process.env.STRAUSS_KB_ACTOR ?? \"unknown\",\n      now: () => new Date().toISOString(),\n    },\n    parsed.data,\n  );\n\n  // A check reporting a problem succeeded as a command and failed as a check;\n  // the command says which, rather than the dispatcher knowing their names.\n  if (command.failsWhen?.(result)) process.exitCode = 1;\n  process.stdout.write(\n    typeof result === \"string\"\n      ? result.endsWith(\"\\n\")\n        ? result\n        : `${result}\\n`\n      : `${JSON.stringify(result, null, 2)}\\n`,\n  );\n}\n\n/**\n * `--bundle` addresses a base directly; without it the command works on the\n * one under the current directory. A base belongs to whatever prompted it, so\n * the default cannot be the only option.\n */\nfunction takeBundle(argv: string[]): { bundle: string; rest: string[] } {\n  const at = argv.indexOf(\"--bundle\");\n  if (at === -1) {\n    return { bundle: join(process.cwd(), KB_DIR), rest: argv };\n  }\n  const bundle = argv[at + 1];\n  if (!bundle) die(\"--bundle requires a path\");\n  return { bundle, rest: [...argv.slice(0, at), ...argv.slice(at + 2)] };\n}\n\nfunction readStdin(): Promise<string> {\n  return new Promise((resolve, reject) => {\n    let text = \"\";\n    process.stdin.setEncoding(\"utf8\");\n    process.stdin.on(\"data\", (chunk) => (text += chunk));\n    process.stdin.on(\"end\", () => resolve(text));\n    process.stdin.on(\"error\", reject);\n  });\n}\n\nfunction die(message: string): never {\n  process.stderr.write(`strauss-kb: error: ${message}\\n`);\n  process.exit(1);\n}\n\n/** First sentence, capped — the full text is what an MCP client shows. */\nfunction summarise(description: string): string {\n  const first = description.split(\"\\n\")[0] ?? \"\";\n  const sentence = first.includes(\". \")\n    ? `${first.slice(0, first.indexOf(\". \"))}.`\n    : first;\n  return sentence.length > 78 ? `${sentence.slice(0, 75)}…` : sentence;\n}\n\nfunction usage(): string {\n  const width = Math.max(...KB_COMMANDS.map((command) => command.usage.length));\n  return [\n    \"strauss-kb — knowledge base commands\",\n    \"\",\n    \"Usage: strauss-kb [--bundle PATH] <command> [args]\",\n    \"\",\n    ...KB_COMMANDS.map(\n      (command) =>\n        `  ${command.usage.padEnd(width)}  ${summarise(command.description)}`,\n    ),\n    \"\",\n    `  --bundle PATH  defaults to ./${KB_DIR}`,\n    \"  STRAUSS_KB_ACTOR names the writer in the log\",\n    \"\",\n  ].join(\"\\n\");\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-WFHYWZX5.js

@@ -0,0 +1,47 @@
+import {
+  KB_COMMANDS,
+  KbStore
+} from "./chunk-ZSYSHJVZ.js";
+
+// src/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+function createKbMcpServer() {
+  const server = new McpServer({ name: "strauss-kb", version: "0.1.0" });
+  const store = new KbStore({
+    warn: (entry) => process.stderr.write(`${JSON.stringify(entry)}
+`)
+  });
+  const ctx = {
+    store,
+    actor: process.env.STRAUSS_KB_ACTOR ?? "mcp",
+    now: () => (/* @__PURE__ */ new Date()).toISOString()
+  };
+  for (const command of KB_COMMANDS) {
+    server.registerTool(
+      command.tool,
+      { description: command.description, inputSchema: command.input.shape },
+      async (args) => {
+        const result = await command.run(ctx, command.input.parse(args));
+        return {
+          content: [
+            {
+              type: "text",
+              text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      }
+    );
+  }
+  return server;
+}
+async function runKbMcpServer() {
+  await createKbMcpServer().connect(new StdioServerTransport());
+}
+
+export {
+  createKbMcpServer,
+  runKbMcpServer
+};
+//# sourceMappingURL=chunk-WFHYWZX5.js.map

package/dist/chunk-WFHYWZX5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/mcp.ts"],"sourcesContent":["import { McpServer } from \"@modelcontextprotocol/sdk/server/mcp.js\";\nimport { StdioServerTransport } from \"@modelcontextprotocol/sdk/server/stdio.js\";\nimport { KB_COMMANDS } from \"./commands.js\";\nimport { KbStore } from \"./kb-store.js\";\n\n/**\n * A knowledge base's own MCP server, over stdio.\n *\n * Standalone because a base is self-contained: a directory of markdown that\n * needs no database, no HTTP surface, and no running service to read. Folding\n * these tools into a larger server would make every consumer start that server\n * to open files it could open itself.\n *\n * Every tool is a projection of `KB_COMMANDS`, which the CLI also projects, so\n * the two cannot drift.\n */\nexport function createKbMcpServer(): McpServer {\n  const server = new McpServer({ name: \"strauss-kb\", version: \"0.1.0\" });\n  const store = new KbStore({\n    warn: (entry) => process.stderr.write(`${JSON.stringify(entry)}\\n`),\n  });\n  const ctx = {\n    store,\n    actor: process.env.STRAUSS_KB_ACTOR ?? \"mcp\",\n    now: () => new Date().toISOString(),\n  };\n\n  for (const command of KB_COMMANDS) {\n    server.registerTool(\n      command.tool,\n      { description: command.description, inputSchema: command.input.shape },\n      async (args: unknown) => {\n        const result = await command.run(ctx, command.input.parse(args));\n        return {\n          content: [\n            {\n              type: \"text\" as const,\n              text:\n                typeof result === \"string\"\n                  ? result\n                  : JSON.stringify(result, null, 2),\n            },\n          ],\n        };\n      },\n    );\n  }\n\n  return server;\n}\n\nexport async function runKbMcpServer(): Promise<void> {\n  await createKbMcpServer().connect(new StdioServerTransport());\n}\n"],"mappings":";;;;;;AAAA,SAAS,iBAAiB;AAC1B,SAAS,4BAA4B;AAe9B,SAAS,oBAA+B;AAC7C,QAAM,SAAS,IAAI,UAAU,EAAE,MAAM,cAAc,SAAS,QAAQ,CAAC;AACrE,QAAM,QAAQ,IAAI,QAAQ;AAAA,IACxB,MAAM,CAAC,UAAU,QAAQ,OAAO,MAAM,GAAG,KAAK,UAAU,KAAK,CAAC;AAAA,CAAI;AAAA,EACpE,CAAC;AACD,QAAM,MAAM;AAAA,IACV;AAAA,IACA,OAAO,QAAQ,IAAI,oBAAoB;AAAA,IACvC,KAAK,OAAM,oBAAI,KAAK,GAAE,YAAY;AAAA,EACpC;AAEA,aAAW,WAAW,aAAa;AACjC,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,EAAE,aAAa,QAAQ,aAAa,aAAa,QAAQ,MAAM,MAAM;AAAA,MACrE,OAAO,SAAkB;AACvB,cAAM,SAAS,MAAM,QAAQ,IAAI,KAAK,QAAQ,MAAM,MAAM,IAAI,CAAC;AAC/D,eAAO;AAAA,UACL,SAAS;AAAA,YACP;AAAA,cACE,MAAM;AAAA,cACN,MACE,OAAO,WAAW,WACd,SACA,KAAK,UAAU,QAAQ,MAAM,CAAC;AAAA,YACtC;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAEA,eAAsB,iBAAgC;AACpD,QAAM,kBAAkB,EAAE,QAAQ,IAAI,qBAAqB,CAAC;AAC9D;","names":[]}