functionalscript 0.43.0 → 0.44.0

package/fjs/mcp/cas/module.f.d.ts

@@ -1,27 +0,0 @@
-import { type MemOp } from '../../effects/memory/module.f.ts';
-import { type ToolEntry } from '../../protocol/mcp/module.f.ts';
-import { type FileCasOperation } from '../../cas/module.f.ts';
-import { type Cache } from '../../cas/evo/module.f.ts';
-import type { Key } from '../../effects/memory/module.f.ts';
-/** Arguments for `cas_add`: content to store, with optional encoding type. */
-export declare const casAddArgs: {
-    readonly content: import("../../types/rtti/module.f.ts").String;
-    readonly type: import("../../types/rtti/module.f.ts").Or<["text", "base64", undefined]>;
-};
-/** Arguments for `cas_get`: the cBase32 hash to look up; optionally request inline content. */
-export declare const casGetArgs: {
-    readonly hash: import("../../types/rtti/module.f.ts").String;
-    readonly content: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Boolean, undefined]>;
-};
-/** Arguments for `cas_list`: none. */
-export declare const casListArgs: {};
-/**
- * Registry of all CAS tools, bound to `home` and the Evo cache at
- * `cacheKey`. `cas_add` is the only tool that writes, so it is the only one
- * that needs `cacheKey`: a successfully stored blob is folded into the Evo
- * cache via `syncRevision` when it happens to be a `vnd.fjs.revision` — a
- * plain `cas_add` and `evo_add` are two ways to reach the same store, and
- * this keeps `evo_list`/`evo_head` honest about either one without a
- * rescan.
- */
-export declare const casToolRegistry: (home: string) => (cacheKey: Key<Cache>) => readonly ToolEntry<FileCasOperation | MemOp>[];

package/fjs/mcp/cas/module.f.js

@@ -1,232 +0,0 @@
-/**
- * The `cas_add` / `cas_get` / `cas_list` tool registry: maps `Cas<O>`
- * operations onto MCP tools, so an agent that speaks MCP can store a blob and
- * get back its hash, fetch a blob by hash, and enumerate what is stored —
- * without shelling out to the `cas` CLI. The store itself
- * (`fjs/cas/module.f.ts`) stays transport-agnostic; this is an additional
- * front end alongside the CLI `main`. This registry is one of the tool sets
- * `fjs/mcp/module.f.ts` composes into the FJS MCP server — see that module
- * for the full tool table (including `fjs/mcp/evo`'s `evo_*` tools) and the
- * server entry point.
- *
- * ## Tools
- *
- * | Tool           | args                          | action           | result                              |
- * |----------------|--------------------------------|------------------|--------------------------------------|
- * | `cas_add`      | `{ content, type? }`          | `c.write(...)`   | hash (cBase32)                      |
- * | `cas_get`      | `{ hash, content?: boolean }` | `c.read(key)`    | JSON `{length,mimeType,type[,uri][,text\|blob]}` |
- * | `cas_list`     | `{}`                          | `c.list()`       | hashes, one per line                |
- *
- * ## `cas_add` input encoding
- *
- * The optional `type` field controls how `content` is interpreted:
- * - `'text'` (default, or omitted): `content` is a UTF-8 string stored as raw
- *   bytes. Most agent-generated content (scripts, JSON, prompts) can be stored
- *   without any encoding step.
- * - `'base64'`: `content` is RFC 4648 base64, decoded to bytes before storage.
- *   Use this for pre-encoded binary payloads.
- *
- * Inline content (either encoding) is capped at 128 KiB (`maxLength`). There is
- * no MCP route for larger content — the server never opens a local path named by
- * the client (see the invariant in `fjs/mcp/README.md`); large files go
- * through the `cas` CLI (`cas add <path>`) instead, run directly by the user.
- *
- * ## `cas_get` output
- *
- * Always returns a JSON object `{ length, mimeType, type[, uri][, text | blob] }`.
- * These field names mirror the MCP resource-contents shape (`resources/read`
- * results), so the tool view and the future resource view of a blob use the same
- * vocabulary: `mimeType` (not `mime_type`), `uri` (not `url`) — the resource URI
- * under which the same blob will be readable via `resources/read` — and `text` /
- * `blob` (not a `type`-tagged `content`) for inline payloads. `type` is always
- * present (`'text'` or `'base64'`) as the discriminator for which of `text` /
- * `blob` a later `content: true` fetch would populate — MCP allows extra fields,
- * so `type` and `length` simply stay alongside the required resource-contents
- * fields. A single classifier — the `fjs/media/type` detector state machine (length ×
- * magic-byte eliminator × UTF-8 DFA) — produces the same three-way verdict on
- * both paths, so there is no second, divergent copy of the rules:
- *
- * 1. **Magic-byte hit** (PNG/JPEG/GIF/WebP/PDF/ZIP) → `type: 'base64'` with the
- *    detected `mimeType`.
- * 2. **Whole-blob-valid UTF-8** → `type: 'text'`, `mimeType: 'text/plain'`.
- * 3. **Fallback** → `type: 'base64'`, `mimeType: 'application/octet-stream'`.
- *
- * **Metadata-only (`content: false`, the default) is size-independent for
- * non-text and oversized blobs.** It folds the read stream through
- * `fjs/media/type` `detectStream` and never buffers the blob. Because a single
- * `Vec` caps at `maxLength` bits (128 KiB), the old drain-into-one-`Vec`
- * approach failed on any blob larger than one chunk even when only metadata
- * was asked for; streaming detection returns correct
- * `{ length, mimeType, type[, uri] }` regardless of size. A dialect (e.g.
- * `vnd.fjs.revision`, see `fjs/media/module.f.ts`) can only be recognized by
- * parsing the whole blob as JSON, so when the streaming verdict is
- * whole-blob-valid text within the same bounded inline cap as `content: true`
- * (`maxLengthBytes`), one extra bounded read materializes the blob purely to
- * refine `mimeType` through the dialect-aware detector; a larger or non-text
- * blob is never a dialect match and is returned from the streaming verdict
- * alone, unbuffered.
- *
- * **`content: true`** first derives `{ length, mimeType, type }` with the same
- * size-independent `fjs/media/type` `detectStream` machine (to decide whether the
- * blob even fits inline), then materializes the bytes (via `collectRead`, bounded
- * by `maxLength`) and re-derives the verdict from the dialect-aware detector
- * (`fjs/media/module.f.ts` `detect`) — now that the whole blob is in hand, a
- * dialect match is reflected in the result — before encoding the inline payload
- * by `type` — a `fjs/text/utf8` `fromVec` string on `text` (for `type: 'text'`),
- * base64 on `blob` (for `type: 'base64'`). A blob larger than `maxLength` (128
- * KiB) cannot be buffered into one `Vec`, so it is rejected here with a
- * descriptive *"too large"* error (carrying the byte size and `uri`) rather than
- * being misreported as absent; it should be fetched via `uri` or inspected with
- * metadata-only `cas_get`.
- *
- * ## Encoding split: hashes vs. content
- *
- * `Cas<O>` deals in `Vec` (bit vectors); MCP models only `textContent` today.
- * **Hashes** travel as cBase32 (`fjs/basen/cbase32`) — the canonical CAS hash format,
- * shared with the CLI and the on-disk store layout. **Content** encoding is
- * determined at read time as described above.
- *
- * ## Error convention
- *
- * MCP draws a line the dispatcher already respects: *protocol* failures
- * (unknown method, malformed JSON-RPC params) are JSON-RPC errors handled by
- * `mcpStep`. *Tool* failures come back as a normal `tools/call` result with
- * `isError: true` and a text explanation, so the model can read and react:
- * - `type: 'base64'` with malformed content (base64 `decode` → `null`) → `isError`
- * - malformed `hash` (`cBase32ToVec` → `null`) → `isError`
- * - `cas_get` on an absent hash (`c.read` → `undefined`) → `isError`
- * - `cas_get` with `content: true` on a blob larger than `maxLength` → `isError`
- *   (distinct "too large" message, not "no such hash")
- * - unknown tool `name` → `isError`
- *
- * @module
- */
-import { string, option, or, boolean } from '../../types/rtti/module.f.js';
-import { stringify } from '../../media/json/module.f.js';
-import { pure, step } from '../../effects/module.f.js';
-import {} from '../../effects/memory/module.f.js';
-import { cBase32ToVec, vecToCBase32 } from '../../basen/cbase32/module.f.js';
-import { decode as base64Decode, encode as base64Encode } from '../../basen/base64/module.f.js';
-import { tryUtf8 } from '../../text/module.f.js';
-import { detectStream } from '../../media/type/module.f.js';
-import { detect } from '../../media/module.f.js';
-import { revisionDialect } from '../../media/revision/module.f.js';
-import { maxLengthBytes } from '../../types/bit_vec/module.f.js';
-import { ok } from '../../types/result/module.f.js';
-import { toolEntry, errorResult, okResult, } from '../../protocol/mcp/module.f.js';
-import { collectRead, fileCas } from '../../cas/module.f.js';
-import { fromVec } from '../../text/utf8/module.f.js';
-import { identity } from '../../types/function/module.f.js';
-import { sha256 } from '../../crypto/sha2/module.f.js';
-import { nonEmpty, empty as elEmpty } from '../../effects/list/module.f.js';
-import { syncRevision } from '../../cas/evo/module.f.js';
-// ── Argument schemas (declared once, used for both inputSchema and validate) ─────
-/** Arguments for `cas_add`: content to store, with optional encoding type. */
-export const casAddArgs = {
-    content: string,
-    type: or('text', 'base64', undefined)
-};
-/** Arguments for `cas_get`: the cBase32 hash to look up; optionally request inline content. */
-export const casGetArgs = {
-    hash: string,
-    content: option(boolean)
-};
-/** Arguments for `cas_list`: none. */
-export const casListArgs = {};
-// ── Tool registry ──────────────────────────────────────────────────────────────
-const toJson = stringify(identity);
-/** The dialect-aware classifier, bound to the dialects this server recognizes. */
-const detectDialect = detect([revisionDialect]);
-/**
- * Registry of all CAS tools, bound to `home` and the Evo cache at
- * `cacheKey`. `cas_add` is the only tool that writes, so it is the only one
- * that needs `cacheKey`: a successfully stored blob is folded into the Evo
- * cache via `syncRevision` when it happens to be a `vnd.fjs.revision` — a
- * plain `cas_add` and `evo_add` are two ways to reach the same store, and
- * this keeps `evo_list`/`evo_head` honest about either one without a
- * rescan.
- */
-export const casToolRegistry = (home) => (cacheKey) => {
-    const c = fileCas(sha256)(home);
-    return [
-        toolEntry('cas_add', 'Store content and return its hash (cBase32). Pass type:"base64" for binary; omit or pass type:"text" for UTF-8 text (default). Inline content is capped at 128 KiB (131072 bytes) — larger content is rejected. For larger content, store the file with the `cas` CLI instead: run `npx functionalscript cas add <path>` yourself if you have shell access, or give the user that exact command to run — it prints the resulting hash on stdout.', casAddArgs, ({ type, content }) => {
-            // type:'text' or 'base64' — resolve content to Vec, store via c.write()
-            let x = type === 'base64'
-                ? base64Decode(content)
-                : tryUtf8(content);
-            return x === null
-                ? pure(errorResult('too large or malformed — for large content, run `npx functionalscript cas add <path>` (or have the user run it) instead'))
-                // The resolved content fits in one chunk; feed it as a single-item stream.
-                : step(c.write(nonEmpty(ok(x), elEmpty())), (writeResult) => {
-                    if (writeResult[0] === 'error') {
-                        return pure(errorResult('write'));
-                    }
-                    const hash = writeResult[1];
-                    return step(syncRevision(cacheKey)(hash)(x), () => pure(okResult(vecToCBase32(hash))));
-                });
-        }),
-        toolEntry('cas_get', 'Inspect a blob by hash. Always returns JSON {length,mimeType,type[,uri]} where type is "text" or "base64". Pass content:true to also include the inline payload as text (type:"text") or blob (type:"base64"), but content is capped at 128 KiB (131072 bytes) — a larger blob is rejected with an error. To download a blob, prefer the uri field returned in the result instead of requesting inline content.', casGetArgs, r => {
-            const key = cBase32ToVec(r.hash);
-            if (key === null) {
-                return pure(errorResult(`invalid cBase32 hash: ${r.hash}`));
-            }
-            const uri = c.url(key);
-            return step(detectStream(c.read(key)), ([tag, detected]) => {
-                if (tag === 'error') {
-                    return pure(errorResult(`no such hash: ${r.hash}`));
-                }
-                const { length, mime_type: mimeType, type } = detected;
-                const meta = { length: Number(length), mimeType, type, uri };
-                if (r.content !== true) {
-                    // A dialect match can only be decided from the whole parsed blob;
-                    // only attempt the extra bounded read when it stands a chance
-                    // (whole-blob text within the same cap `content: true` allows).
-                    if (type !== 'text' || length > maxLengthBytes) {
-                        return pure(okResult(toJson(meta)));
-                    }
-                    return step(collectRead(c.read(key)), ([collectTag, value]) => {
-                        // Already known to fit from the streaming pass above, so an
-                        // error here means the hash vanished between reads; fall back
-                        // to the streaming verdict rather than fail the whole request.
-                        if (collectTag === 'error') {
-                            return pure(okResult(toJson(meta)));
-                        }
-                        const refined = detectDialect(value);
-                        return pure(okResult(toJson({ ...meta, mimeType: refined.mime_type })));
-                    });
-                }
-                // A single `Vec` caps at `maxLength` bits (`maxLengthBytes` bytes), so
-                // a larger blob cannot be buffered for inline transfer. Report the
-                // size and point at the size-independent alternatives instead of
-                // misreporting an existing blob as `no such hash`.
-                if (length > maxLengthBytes) {
-                    return pure(errorResult(`blob too large to fetch inline (${length} bytes, limit ${maxLengthBytes} bytes); use the uri field (${uri}) or omit content for metadata`));
-                }
-                return step(collectRead(c.read(key)), ([collectTag, value]) => {
-                    if (collectTag === 'error') {
-                        return pure(errorResult(`no such hash: ${r.hash}`));
-                    }
-                    // Re-derive the verdict from the now-materialized blob so a
-                    // dialect match — only decidable with the whole parsed JSON in
-                    // hand — is reflected in the inline result too, not just the
-                    // streaming guess.
-                    const refined = detectDialect(value);
-                    const refinedMeta = { length: Number(refined.length), mimeType: refined.mime_type, type: refined.type, uri };
-                    if (refined.type === 'text') {
-                        // `type: 'text'` means the detector validated `value` as UTF-8,
-                        // so `fromVec` is non-null here; guard defensively regardless.
-                        const str = fromVec(value);
-                        return pure(str === null
-                            ? errorResult(`content is not byte-aligned: ${r.hash}`)
-                            : okResult(toJson({ ...refinedMeta, text: str })));
-                    }
-                    const blob = base64Encode(value);
-                    return pure(blob === null
-                        ? errorResult(`content is not byte-aligned: ${r.hash}`)
-                        : okResult(toJson({ ...refinedMeta, blob })));
-                });
-            });
-        }),
-        toolEntry('cas_list', 'List all stored content hashes (cBase32), one per line.', casListArgs, () => step(c.list(), hashes => pure(okResult(hashes.map(vecToCBase32).join('\n'))))),
-    ];
-};

package/fjs/mcp/evo/module.f.d.ts

@@ -1,32 +0,0 @@
-import { type Operation } from '../../effects/module.f.ts';
-import { type MemOp } from '../../effects/memory/module.f.ts';
-import { type ToolEntry } from '../../protocol/mcp/module.f.ts';
-import { type Evo } from '../../cas/evo/module.f.ts';
-/**
- * Arguments for `evo_list`: an optional status filter, forwarded unchanged to
- * `Evo.list` — omitted lists the active subjects, `true` the archived ones.
- */
-export declare const evoListArgs: {
-    readonly archived: import("../../types/rtti/module.f.ts").Or<readonly [true, undefined]>;
-};
-/** Arguments for `evo_head`: the subject whose current heads are requested. */
-export declare const evoHeadArgs: {
-    readonly subject: import("../../types/rtti/module.f.ts").String;
-};
-/** Arguments for `evo_revision`: the hash of the revision to read. */
-export declare const evoRevisionArgs: {
-    readonly hash: import("../../types/rtti/module.f.ts").String;
-};
-/**
- * Arguments for `evo_add`: a new revision, per `fjs/cas/evo`'s
- * `RevisionData` — every field of it the caller supplies, i.e. all but
- * `generation`, which the server computes.
- */
-export declare const evoAddArgs: {
-    readonly parents: import("../../types/rtti/module.f.ts").Type1<"array", import("../../types/rtti/module.f.ts").String>;
-    readonly snapshot: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
-    readonly subject: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
-    readonly archived: import("../../types/rtti/module.f.ts").Or<readonly [true, undefined]>;
-};
-/** Registry of all Evo tools, bound to an `Evo<O>`. */
-export declare const evoToolRegistry: <O extends Operation>(e: Evo<O>) => readonly ToolEntry<O | MemOp>[];

package/fjs/mcp/evo/module.f.js

@@ -1,99 +0,0 @@
-/**
- * MCP tool definitions for the Evo API (`fjs/cas/evo/module.f.ts`): subjects,
- * revision heads, and the typed read of a single revision over the
- * content-addressable store, backed by the in-memory cache the core module
- * maintains.
- *
- * ## Tools
- *
- * | Tool           | args                                          | action            | result                               |
- * |----------------|-----------------------------------------------|-------------------|--------------------------------------|
- * | `evo_list`     | `{ archived? }`                               | `e.list(...)`     | subjects, as a JSON array of strings |
- * | `evo_head`     | `{ subject }`                                 | `e.head(...)`     | head hashes, one per line            |
- * | `evo_revision` | `{ hash }`                                    | `e.revision(...)` | the revision, as JSON `RevisionData` |
- * | `evo_add`      | `{ parents, snapshot?, subject?, archived? }`  | `e.add(...)`      | hash (cBase32)                       |
- *
- * `evo_add` and `evo_revision` speak the same structure — `fjs/cas/evo`'s
- * `RevisionData` — in opposite directions, so a revision read back can be
- * added again as-is. `evo_add`'s advertised arguments stay as they are: the
- * one field `evo_revision` returns that `evo_add` does not accept is
- * `generation`, which the server computes, and rtti's struct validation
- * ignores properties the schema does not name, so a whole `evo_revision`
- * result can be passed straight back to `evo_add`.
- *
- * ## Result size
- *
- * `evo_list` and `evo_revision` answer with JSON carried as MCP *text*
- * content, so the JSON-RPC serializer escapes it a second time on the way
- * out and a modest result can encode to a much longer line (a subject of
- * quote characters is the worst case). A response whose encoded line exceeds
- * the transport cap is not lost: `fjs/protocol/mcp/stdio` retries with a small
- * `-32603` body carrying the request's `id`, so every request still gets a
- * response and the process never crashes. That is the transport's contract
- * for every tool — `cas_get` has proofs for the same double-escaping path —
- * and no tool here can pre-empt it: whether the encoded response fits is
- * known only by encoding it, which is the transport's job, and guessing from
- * an unencoded size is exactly the size estimate that must never be made.
- *
- * These tools are not served by their own process: `fjs/mcp` (the same
- * server as `cas_add`/`cas_get`/`cas_list`) builds one `Evo<O>` from its own
- * `Cas<O>` and cache slot, concatenates `evoToolRegistry` onto its own
- * registry, and serves everything from that single process — one `~/.cas/`
- * store, one Evo cache, one server.
- *
- * @module
- */
-import { string, option, array } from '../../types/rtti/module.f.js';
-import { pure, step } from '../../effects/module.f.js';
-import {} from '../../effects/memory/module.f.js';
-import { toolEntry, errorResult, okResult, } from '../../protocol/mcp/module.f.js';
-import { stringify } from '../../media/json/module.f.js';
-import { identity } from '../../types/function/module.f.js';
-import {} from '../../cas/evo/module.f.js';
-// ── Argument schemas (declared once, used for both inputSchema and validate) ─────
-/**
- * Arguments for `evo_list`: an optional status filter, forwarded unchanged to
- * `Evo.list` — omitted lists the active subjects, `true` the archived ones.
- */
-export const evoListArgs = {
-    archived: option(true),
-};
-/** Arguments for `evo_head`: the subject whose current heads are requested. */
-export const evoHeadArgs = {
-    subject: string,
-};
-/** Arguments for `evo_revision`: the hash of the revision to read. */
-export const evoRevisionArgs = {
-    hash: string,
-};
-/**
- * Arguments for `evo_add`: a new revision, per `fjs/cas/evo`'s
- * `RevisionData` — every field of it the caller supplies, i.e. all but
- * `generation`, which the server computes.
- */
-export const evoAddArgs = {
-    parents: array(string),
-    snapshot: option(string),
-    subject: option(string),
-    archived: option(true),
-};
-// ── Tool registry ────────────────────────────────────────────────────────────────
-/** Canonical JSON encoder for the `evo_list` and `evo_revision` results. */
-const toJson = stringify(identity);
-/** Registry of all Evo tools, bound to an `Evo<O>`. */
-export const evoToolRegistry = (e) => [
-    toolEntry('evo_list', 'List subjects, as a JSON array of strings. By default only the active ones: a subject is active while at least one of its current heads is not archived. Pass `archived: true` to list the archived subjects instead — those with at least one current head, all of them archived. A subject with no current heads is in neither list.', evoListArgs, 
-    // Subjects are arbitrary caller-supplied strings (unlike hashes, not
-    // constrained to a newline-free alphabet), so a `join('\n')` line
-    // format could not represent an empty subject or one containing a
-    // newline without ambiguity — JSON encoding can.
-    ({ archived }) => step(e.list(archived), subjects => pure(okResult(toJson(subjects))))),
-    toolEntry('evo_head', 'List the current head hashes (cBase32) of a subject, one per line. Empty when the subject is unknown.', evoHeadArgs, ({ subject }) => step(e.head(subject), heads => pure(okResult(heads.join('\n'))))),
-    toolEntry('evo_revision', 'Read one revision by hash, as JSON: `{ subject, parents, snapshot, generation, archived? }`. `parents[0]` is the mainline parent and every further entry is a merged-in branch; `parents` and `snapshot` come back in their canonical cBase32 spelling, so they compare directly against `evo_head` output. Errors when the hash is not cBase32, is not present in the store, could not be read, or does not hold a `vnd.fjs.revision` blob — use `cas_get` for raw bytes of non-revision content.', evoRevisionArgs, 
-    // The revision goes out as JSON in a text content item, like
-    // `evo_list`'s. An encoded response that outgrows the transport cap is
-    // the transport's `-32603`, not a tool-level error — see "Result size"
-    // in the module doc.
-    ({ hash }) => step(e.revision(hash), result => pure(result[0] === 'error' ? errorResult(result[1]) : okResult(toJson(result[1]))))),
-    toolEntry('evo_add', 'Add a new revision (a `vnd.fjs.revision` blob) and return its hash (cBase32). `subject` is required unless there is exactly one parent, from which it is inherited. `snapshot`, when omitted, is resolved from the parents (zero parents → `subject`, one parent → the parent\'s snapshot; a merge requires an explicit `snapshot`) and written explicitly. `generation` is computed by the server.', evoAddArgs, (input) => step(e.add(input), result => pure(result[0] === 'error' ? errorResult(result[1]) : okResult(result[1])))),
-];

package/fjs/mcp/evo/proof.f.d.ts

@@ -1,12 +0,0 @@
-export declare const proof: {
-    toolNamesMatchTheDesign: () => void;
-    evoListReflectsTheCache: () => void;
-    evoListEncodesArbitrarySubjectsAsJson: () => void;
-    evoListForwardsTheArchivedFilter: () => void;
-    evoHeadReflectsTheCache: () => void;
-    evoHeadMissingSubjectIsInvalidArguments: () => void;
-    evoRevisionReturnsRevisionJson: () => void;
-    evoRevisionDomainErrorIsError: () => void;
-    evoAddSuccessReturnsHash: () => void;
-    evoAddDomainErrorIsError: () => void;
-};

package/fjs/mcp/evo/proof.f.js

@@ -1,147 +0,0 @@
-import { assert, assertEq } from '../../asserts/module.f.js';
-import { fileCas } from '../../cas/module.f.js';
-import { sha256 } from '../../crypto/sha2/module.f.js';
-import { emptyState, virtual } from '../../effects/node/virtual/module.f.js';
-import { vec8 } from '../../types/bit_vec/module.f.js';
-import { vecToCBase32 } from '../../basen/cbase32/module.f.js';
-import { initEvo, evo } from '../../cas/evo/module.f.js';
-import { evoToolRegistry } from './module.f.js';
-import { parse as parseJson } from '../../media/json/module.f.js';
-import { array, string as rttiString } from '../../types/rtti/module.f.js';
-import { parse as rttiParse } from '../../types/rtti/parse/module.f.js';
-import { unwrap } from '../../types/result/module.f.js';
-const home = '/home/user';
-const parseSubjects = rttiParse(array(rttiString));
-const findEntry = (registry, name) => {
-    const entry = registry.find(e => e.name === name);
-    assert(entry !== undefined, ['missing tool entry', name]);
-    return entry;
-};
-const textOf = (result) => {
-    const [item] = result.content;
-    assert(item.type === 'text', ['expected a text content item', item]);
-    return item.text;
-};
-export const proof = {
-    toolNamesMatchTheDesign: () => {
-        const e = {
-            list: () => { throw 'unused'; },
-            head: () => { throw 'unused'; },
-            add: () => { throw 'unused'; },
-            revision: () => { throw 'unused'; },
-        };
-        assertEq(evoToolRegistry(e).map(entry => entry.name).join(','), 'evo_list,evo_head,evo_revision,evo_add');
-    },
-    evoListReflectsTheCache: () => {
-        const c = fileCas(sha256)(home);
-        const [state0, cacheKey] = virtual(emptyState)(initEvo(c));
-        const e = evo(c)(cacheKey);
-        const entry = findEntry(evoToolRegistry(e), 'evo_list');
-        const [, result] = virtual(state0)(entry.handle({}));
-        assert(!result.isError);
-        assertEq(textOf(result), '[]');
-    },
-    // Regression: subjects are arbitrary strings, not constrained to a
-    // newline-free alphabet like hashes, so evo_list must not join them with
-    // '\n' — a subject containing a newline, or an empty subject, would be
-    // indistinguishable from multiple/no subjects in that format. JSON
-    // encoding preserves both exactly.
-    evoListEncodesArbitrarySubjectsAsJson: () => {
-        const c = fileCas(sha256)(home);
-        const [state0, cacheKey] = virtual(emptyState)(initEvo(c));
-        const e = evo(c)(cacheKey);
-        const [state1, addA] = virtual(state0)(e.add({ parents: [], subject: 'line one\nline two', snapshot: vecToCBase32(vec8(0x2an)) }));
-        assert(addA[0] === 'ok', ['expected add ok', addA]);
-        const [state2, addB] = virtual(state1)(e.add({ parents: [], subject: '', snapshot: vecToCBase32(vec8(0x2bn)) }));
-        assert(addB[0] === 'ok', ['expected add ok', addB]);
-        const entry = findEntry(evoToolRegistry(e), 'evo_list');
-        const [, result] = virtual(state2)(entry.handle({}));
-        assert(!result.isError);
-        const subjects = unwrap(parseSubjects(unwrap(parseJson(textOf(result)))));
-        assertEq(subjects.length, 2);
-        assert(subjects.includes('line one\nline two'), ['unexpected subjects', subjects]);
-        assert(subjects.includes(''), ['unexpected subjects', subjects]);
-    },
-    // The `archived` argument is a pass-through to `Evo.list`'s status filter:
-    // omitted lists the active subjects, `true` the archived ones.
-    evoListForwardsTheArchivedFilter: () => {
-        const c = fileCas(sha256)(home);
-        const [state0, cacheKey] = virtual(emptyState)(initEvo(c));
-        const e = evo(c)(cacheKey);
-        const [state1, add] = virtual(state0)(e.add({ parents: [], subject: 'gone', snapshot: vecToCBase32(vec8(0x2cn)), archived: true }));
-        assert(add[0] === 'ok', ['expected add ok', add]);
-        const entry = findEntry(evoToolRegistry(e), 'evo_list');
-        const [state2, active] = virtual(state1)(entry.handle({}));
-        assert(!active.isError);
-        assertEq(textOf(active), '[]');
-        const [, archived] = virtual(state2)(entry.handle({ archived: true }));
-        assert(!archived.isError);
-        assertEq(textOf(archived), '["gone"]');
-    },
-    evoHeadReflectsTheCache: () => {
-        const c = fileCas(sha256)(home);
-        const [state0, cacheKey] = virtual(emptyState)(initEvo(c));
-        const e = evo(c)(cacheKey);
-        const entry = findEntry(evoToolRegistry(e), 'evo_head');
-        const [, result] = virtual(state0)(entry.handle({ subject: 'nope' }));
-        assert(!result.isError);
-        assertEq(textOf(result), '');
-    },
-    evoHeadMissingSubjectIsInvalidArguments: () => {
-        const c = fileCas(sha256)(home);
-        const [state0, cacheKey] = virtual(emptyState)(initEvo(c));
-        const e = evo(c)(cacheKey);
-        const entry = findEntry(evoToolRegistry(e), 'evo_head');
-        const [, result] = virtual(state0)(entry.handle({}));
-        assertEq(result.isError, true);
-    },
-    // Covers evo_revision's success branch: the stored revision comes back as
-    // the JSON of `RevisionData` — `dialect` dropped, `generation` and the
-    // resolved `snapshot` included.
-    evoRevisionReturnsRevisionJson: () => {
-        const c = fileCas(sha256)(home);
-        const [state0, cacheKey] = virtual(emptyState)(initEvo(c));
-        const e = evo(c)(cacheKey);
-        const subject = vecToCBase32(vec8(0x3n));
-        const [state1, added] = virtual(state0)(e.add({ parents: [], subject }));
-        assert(added[0] === 'ok', ['expected add ok', added]);
-        const entry = findEntry(evoToolRegistry(e), 'evo_revision');
-        const [, result] = virtual(state1)(entry.handle({ hash: added[1] }));
-        assert(!result.isError);
-        assertEq(textOf(result), `{"subject":"${subject}","parents":[],"snapshot":"${subject}","generation":0}`);
-    },
-    // Covers evo_revision's error branch: a domain-level failure (a hash the
-    // store has nothing under) is surfaced as isError with the message.
-    evoRevisionDomainErrorIsError: () => {
-        const c = fileCas(sha256)(home);
-        const [state0, cacheKey] = virtual(emptyState)(initEvo(c));
-        const e = evo(c)(cacheKey);
-        const entry = findEntry(evoToolRegistry(e), 'evo_revision');
-        const [, result] = virtual(state0)(entry.handle({ hash: vecToCBase32(vec8(0x4n)) }));
-        assertEq(result.isError, true);
-        assert(textOf(result).includes('revision not found'));
-    },
-    // Covers evo_add's success branch: a valid revision is stored and its
-    // hash comes back as plain, non-error text.
-    evoAddSuccessReturnsHash: () => {
-        const c = fileCas(sha256)(home);
-        const [state0, cacheKey] = virtual(emptyState)(initEvo(c));
-        const e = evo(c)(cacheKey);
-        const entry = findEntry(evoToolRegistry(e), 'evo_add');
-        const args = { parents: [], subject: 'doc', snapshot: vecToCBase32(vec8(0x1n)) };
-        const [, result] = virtual(state0)(entry.handle(args));
-        assert(!result.isError);
-        assert(textOf(result).length > 0);
-    },
-    // Covers evo_add's error branch: a domain-level failure (Evo.add's
-    // Result) is surfaced as isError with the failure message as text.
-    evoAddDomainErrorIsError: () => {
-        const c = fileCas(sha256)(home);
-        const [state0, cacheKey] = virtual(emptyState)(initEvo(c));
-        const e = evo(c)(cacheKey);
-        const entry = findEntry(evoToolRegistry(e), 'evo_add');
-        const [, result] = virtual(state0)(entry.handle({ parents: [] }));
-        assertEq(result.isError, true);
-        assert(textOf(result).includes('subject is required'));
-    },
-};

package/fjs/mcp/module.f.d.ts

@@ -1,56 +0,0 @@
-/**
- * The FJS MCP server: the composition root the `fjs mcp` / `m` CLI command
- * runs. Session configuration (`McpConfig`), the top-level entry point
- * (`casMcpServer`, wiring `mcpStep` + `stdioTransport` from
- * `fjs/protocol/mcp/`), and the composed tool registry — nothing CAS- or
- * Evo-specific lives here, it only knows about tool *registries*, not what is
- * in them, so a future non-CAS tool set can land as a new sibling of
- * `fjs/mcp/cas/` and `fjs/mcp/evo/` without touching either of them.
- *
- * ## Tools
- *
- * | Tool           | args                                          | action           | result                              |
- * |----------------|------------------------------------------------|------------------|--------------------------------------|
- * | `cas_add`      | `{ content, type? }`                          | `c.write(...)`   | hash (cBase32)                      |
- * | `cas_get`      | `{ hash, content?: boolean }`                 | `c.read(key)`    | JSON `{length,mimeType,type[,uri][,text\|blob]}` |
- * | `cas_list`     | `{}`                                          | `c.list()`       | hashes, one per line                |
- * | `evo_list`     | `{ archived? }`                               | `e.list(...)`    | subjects, as a JSON array of strings |
- * | `evo_head`     | `{ subject }`                                 | `e.head(...)`    | head hashes, one per line           |
- * | `evo_revision` | `{ hash }`                                    | `e.revision(...)`| the revision, as JSON               |
- * | `evo_add`      | `{ parents, snapshot?, subject?, archived? }` | `e.add(...)`     | hash (cBase32)                      |
- *
- * `cas_add`/`cas_get`/`cas_list` are `fjs/mcp/cas` — see that module for tool
- * documentation (input encoding, output shape, error convention). `evo_*` is
- * `fjs/mcp/evo`. Both tool sets run in one process, sharing one `~/.cas/`
- * store and one in-memory Evo cache scanned once at startup (`initEvo`).
- *
- * @module
- */
-import { type Effect } from '../effects/module.f.ts';
-import { type MemOp } from '../effects/memory/module.f.ts';
-import { type Read, type Write } from '../effects/node/module.f.ts';
-import { type McpConfig, type McpHandlers } from '../protocol/mcp/module.f.ts';
-import { type FileCasOperation } from '../cas/module.f.ts';
-import { type Cache } from '../cas/evo/module.f.ts';
-import type { Key } from '../effects/memory/module.f.ts';
-/**
- * MCP handlers for `FileCas` (`fjs/mcp/cas`) plus the Evo API (`fjs/mcp/evo`)
- * layered on it, bound to `home` and an already-built Evo cache slot (see
- * `initEvo`).
- */
-export declare const casMcpHandlers: (home: string) => (cacheKey: Key<Cache>) => McpHandlers<FileCasOperation | MemOp>;
-/**
- * Static MCP configuration for the CAS server: advertises the `tools`
- * capability, identifies the server, and pins the protocol version.
- */
-export declare const casConfig: McpConfig;
-/**
- * Runs the combined CAS + Evo MCP server over stdio: scans `~/.cas/` once to
- * build the Evo subject/head cache (`initEvo`), allocates the session-state
- * slot, builds the `mcpStep` for the merged tool registry, and drives the
- * read → parse → dispatch → write loop until stdin EOF.
- */
-export declare const casMcpServer: (home: string) => Effect<Read | Write | MemOp | FileCasOperation, void>;
-export declare const proof: {
-    casMcpServer: () => void;
-};