super-dsh 0.1.0 → 0.1.2

package/agent-claude/dist/commands.js

@@ -0,0 +1,182 @@
+/**
+ * Claude Code's observed slash commands, registered onto `ctx.commands`.
+ *
+ * Claude owns a command surface (`session_init.slash_commands`): `/mcp`,
+ * `/clear`, `/review`, plugin-namespaced commands, and so on. DSH exposes its
+ * own registry to the composer, so the adapter mirrors each observed Claude
+ * command there and lets the user pick it from the same menu.
+ *
+ * Two deliberate rules:
+ *
+ * - **Every registered id is `claude-<name>`.** Prefixing is total — the id is
+ *   the only thing this module writes to the shared registry, so it must be
+ *   collision-free with DSH's own `/compact`, `/plan`, `/permission`, … AND
+ *   self-explanatory about its owner. A name that already carries the prefix is
+ *   still prefixed once more (`claude-mcp` -> `claude-claude-mcp`): de-prefixing
+ *   would alias two genuinely distinct observed names onto one id.
+ * - **The handler forwards, it never renders.** `submit` receives
+ *   `/mcp` plus the raw tail exactly as the user typed it (the registry hands
+ *   the tail through unnormalized), so Claude's own command parser sees its
+ *   original line. The panel/output for the command flows back through the
+ *   ordinary transcript projection.
+ *
+ * The invocation's id is sanitized for DSH's command-id grammar
+ * (`^[a-z][a-z0-9_-]*$`) — lowercase, invalid runs become `-` — but the
+ * FORWARDED line keeps the observed spelling, so sanitizing is invisible to
+ * Claude.
+ */
+// No Cordis import: the runtime surface this module needs is described
+// structurally below, which keeps the module loadable (and testable) without a
+// Cordis host, and keeps the adapter's runtime dependency set unchanged.
+/** DSH's command-id grammar (`@deepseek-ai/dsh-commands`' `COMMAND_NAME`). */
+const COMMAND_ID_BODY = /[^a-z0-9_-]+/gu;
+/**
+ * Sanitize one observed Claude name into a `claude-` prefixed DSH command id.
+ *
+ * The prefix guarantees the grammar's leading-lowercase-letter requirement, so
+ * the only work left is mapping the body to `[a-z0-9_-]`. The mapping is total
+ * and deterministic: uppercase folds, every invalid run becomes one `-`.
+ *
+ * @returns the command id, or `undefined` when nothing usable is left.
+ */
+function claudeCommandId(observed) {
+    const body = observed.toLowerCase().replace(COMMAND_ID_BODY, "-");
+    return body === "" ? undefined : `claude-${body}`;
+}
+/**
+ * Build the discovery summary. The registry rejects an empty description, so a
+ * missing/blank observed one falls back to a constant; a real one is prefixed
+ * so every entry in the menu declares its owner.
+ */
+function claudeDescription(observed) {
+    const text = typeof observed === "string" ? observed.trim() : "";
+    return text === "" ? "Claude Code slash command" : `Claude Code: ${text}`;
+}
+/** The observed name, trimmed; blank/non-string input yields `""` (skip). */
+function observedName(command) {
+    const raw = command?.name;
+    return typeof raw === "string" ? raw.trim() : "";
+}
+/**
+ * Normalize ONE reported entry — a bare name string (`session_init.slash_commands`
+ * is `string[]`) or an SDK `SlashCommand` object (`supportedCommands()` carries
+ * the description and argument hint) — into the shape this module registers.
+ *
+ * @returns the entry, or `undefined` when the report carries no usable name.
+ */
+function reportedEntry(raw) {
+    const record = typeof raw === "string"
+        ? { name: raw }
+        : typeof raw === "object" && raw !== null ? raw : undefined;
+    if (record === undefined)
+        return undefined;
+    const name = typeof record.name === "string" ? record.name.trim() : "";
+    if (name === "")
+        return undefined;
+    const description = typeof record.description === "string" ? record.description.trim() : "";
+    const argumentHint = typeof record.argumentHint === "string" ? record.argumentHint.trim() : "";
+    return {
+        name,
+        ...description === "" ? {} : { description },
+        ...argumentHint === "" ? {} : { argumentHint },
+    };
+}
+/**
+ * Normalize everything Claude reported about its command surface into the
+ * registration list, de-duplicated by name (first report wins — the SDK's
+ * `aliases` are alternate spellings of the same command, deliberately NOT
+ * separate menu entries).
+ *
+ * Accepts the `session_init` name list and the richer `supportedCommands()`
+ * objects through the same door, so the two observation sources cannot drift
+ * in their filtering rules.
+ *
+ * @param raw - the reported array, in either shape; anything else yields `[]`.
+ * @returns the usable entries in report order.
+ */
+export function slashCommandsFromReported(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const seen = new Set();
+    const entries = [];
+    for (const item of raw) {
+        const entry = reportedEntry(item);
+        if (entry === undefined || seen.has(entry.name))
+            continue;
+        seen.add(entry.name);
+        entries.push(entry);
+    }
+    return entries;
+}
+/**
+ * Mirror every observed Claude slash command onto `ctx.commands`.
+ *
+ * Skips (never throws on) an observed entry whose name is absent, non-string,
+ * or blank; de-duplicates by resulting command id so a repeated observation
+ * cannot double-register; and rolls back (releases) every registration already
+ * made when a later `register` throws, so a partial mirror never leaks.
+ *
+ * @param ctx - a context whose `commands` registry is reachable.
+ * @param deps - the observed command list plus the exact-line submit sink.
+ * @returns a disposer that releases EVERY registration this call made (once).
+ */
+export function registerClaudeCommands(ctx, deps) {
+    const disposers = [];
+    const registered = new Set();
+    let disposed = false;
+    /** Release every registration made so far; the returned disposer, guarded. */
+    const disposeAll = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        let firstError;
+        for (const dispose of disposers.splice(0)) {
+            try {
+                dispose();
+            }
+            catch (error) {
+                // One bad disposer must not strand the others: collect and re-raise.
+                if (firstError === undefined)
+                    firstError = error;
+            }
+        }
+        if (firstError !== undefined)
+            throw firstError;
+    };
+    try {
+        for (const command of deps.listSlashCommands() ?? []) {
+            const observed = observedName(command);
+            if (observed === "")
+                continue;
+            const name = claudeCommandId(observed);
+            if (name === undefined || registered.has(name))
+                continue;
+            registered.add(name);
+            const hint = command?.argumentHint;
+            const trimmedHint = typeof hint === "string" ? hint.trim() : "";
+            const dispose = ctx.commands.register({
+                name,
+                description: claudeDescription(command?.description),
+                ...trimmedHint === "" ? {} : { input: { hint: trimmedHint } },
+                handler: (invocation) => {
+                    deps.submit(invocation.agent, `/${observed}${invocation.rawInput}`);
+                    return { kind: "success" };
+                },
+            });
+            if (typeof dispose === "function")
+                disposers.push(dispose);
+        }
+    }
+    catch (error) {
+        // A partial registration must not leak: release what landed, then report
+        // the original failure (a disposer's own throw must not mask it).
+        try {
+            disposeAll();
+        }
+        catch {
+            /* the registration failure below stays the reported one */
+        }
+        throw error;
+    }
+    return disposeAll;
+}

package/agent-claude/dist/content.js

@@ -0,0 +1,134 @@
+/**
+ * DSH content blocks -> Anthropic message content blocks.
+ *
+ * The paste/prompt UI is DSH's own; the adapter owns the transcoding into
+ * Claude's wire shape (spec ruling R14). A block whose payload cannot be
+ * resolved is SKIPPED AND REPORTED: an unattachable image must never silently
+ * vanish, and an unusable placeholder must never be sent to the runtime.
+ *
+ * The module is deliberately PURE — no SDK import and no I/O. It produces plain
+ * JSON blocks and the caller injects whatever attachment reader it owns, so the
+ * projection can be pinned by a unit test without a store, a CLI, or a session.
+ *
+ * ## Skip policy (every skip is loud)
+ *
+ * - a non-object entry, a missing/empty/non-string text, or an empty text block
+ *   (the Anthropic API rejects empty text blocks, so normalizing one away is a
+ *   reported drop, not a silent trim);
+ * - an unknown block `type`;
+ * - an `image`/`file` with neither inline `data` nor a resolvable
+ *   `attachmentId`;
+ * - an `attachmentId` the injected reader cannot resolve (or one that throws —
+ *   the reader's failure is contained here and becomes a reported skip);
+ * - a missing/empty `mediaType`, or a media type that is not `image/*`: the
+ *   output must never carry `media_type: undefined` or a non-image source;
+ * - ANY `file` block. DSH's `file` block is a verbatim attachment reference —
+ *   the harness contract is that files never reach a provider natively and are
+ *   projected to deterministic handle text instead, so this adapter must not
+ *   launder one into an image block. It is reported instead.
+ */
+/** Whether a media type may ride an Anthropic base64 image source. */
+function isImageMediaType(mediaType) {
+    return mediaType.startsWith("image/");
+}
+/** A non-empty string field, or undefined when absent/blank/unusable. */
+function stringField(value) {
+    return typeof value === "string" && value !== "" ? value : undefined;
+}
+/** Human-readable detail for a contained reader failure. */
+function errorDetail(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message === "" ? "unknown error" : message;
+}
+/**
+ * Transcode DSH user content blocks into Anthropic input blocks.
+ *
+ * @param blocks - DSH user content blocks in message order. Entries are read
+ *   defensively: a null/undefined/non-object member is reported, not fatal.
+ * @param readAttachment - synchronous resolver for a durable attachment id.
+ *   Returning `undefined` means "not resolvable" and becomes a reported skip;
+ *   throwing is contained into a reported skip as well. A block carrying inline
+ *   `data` never consults it.
+ * @returns the attachable blocks in input order plus one actionable reason per
+ *   block that could not be attached.
+ */
+export function toClaudeContent(blocks, readAttachment) {
+    const content = [];
+    const skipped = [];
+    const source = Array.isArray(blocks) ? blocks : [];
+    for (let index = 0; index < source.length; index += 1) {
+        const entry = source[index];
+        if (entry === null || entry === undefined || typeof entry !== "object") {
+            skipped.push(`block at index ${index}: not a content block object`);
+            continue;
+        }
+        const block = entry;
+        if (block.type === "text") {
+            const text = block.text;
+            if (typeof text !== "string") {
+                skipped.push(`text block at index ${index}: missing text`);
+                continue;
+            }
+            if (text === "") {
+                skipped.push(`text block at index ${index}: empty text`);
+                continue;
+            }
+            // Byte-exact, and one output block per input block: consecutive text
+            // blocks are legal on the wire, and merging them would change the shape.
+            content.push({ type: "text", text });
+            continue;
+        }
+        if (block.type !== "image" && block.type !== "file") {
+            skipped.push(`block at index ${index}: unknown block type ${JSON.stringify(block.type)}`);
+            continue;
+        }
+        if (block.type === "file") {
+            // DSH's `file` block is a verbatim attachment reference. The harness
+            // contract is that files never reach a provider natively (they are
+            // projected to deterministic handle text), so a file block is NEVER
+            // emitted as an image block here — even when its payload looks like a
+            // raster image. Reported instead, and never resolved through the image
+            // reader.
+            const fileMediaType = stringField(block.mediaType);
+            skipped.push(`file block at index ${index}: verbatim file references cannot be attached to Claude` +
+                (fileMediaType === undefined ? "" : ` (mediaType "${fileMediaType}")`));
+            continue;
+        }
+        let mediaType = stringField(block.mediaType);
+        let data = stringField(block.data);
+        const attachmentId = stringField(block.attachmentId);
+        if (data === undefined && attachmentId !== undefined) {
+            let resolved;
+            try {
+                resolved = readAttachment(attachmentId);
+            }
+            catch (error) {
+                skipped.push(`${block.type} block at index ${index}: reading attachment "${attachmentId}" failed (${errorDetail(error)})`);
+                continue;
+            }
+            if (resolved !== undefined && resolved !== null && typeof resolved === "object") {
+                if (mediaType === undefined)
+                    mediaType = stringField(resolved.mediaType);
+                if (data === undefined)
+                    data = stringField(resolved.data);
+            }
+        }
+        if (data === undefined) {
+            skipped.push(`${block.type} block at index ${index}: no inline data` +
+                (attachmentId === undefined
+                    ? " and no attachmentId"
+                    : ` and attachment "${attachmentId}" could not be resolved`));
+            continue;
+        }
+        if (mediaType === undefined) {
+            skipped.push(`${block.type} block at index ${index}: missing mediaType`);
+            continue;
+        }
+        if (!isImageMediaType(mediaType)) {
+            skipped.push(`${block.type} block at index ${index}: media type "${mediaType}" is not an image media type`);
+            continue;
+        }
+        content.push({ type: "image", source: { type: "base64", media_type: mediaType, data } });
+    }
+    return { content, skipped };
+}

package/agent-claude/dist/inbox.js

@@ -0,0 +1,53 @@
+export class Inbox {
+    nextTurnList = [];
+    nextStepList = [];
+    get nextTurn() {
+        return this.nextTurnList;
+    }
+    get nextStep() {
+        return this.nextStepList;
+    }
+    clear() {
+        this.nextTurnList = [];
+        this.nextStepList = [];
+    }
+    append(target, message) {
+        this.list(target).push(message);
+    }
+    prepend(target, message) {
+        this.list(target).unshift(message);
+    }
+    replace(messageId, newMessage) {
+        const list = this.find(messageId);
+        if (list === undefined)
+            return false;
+        const index = list.findIndex((message) => message.id === messageId);
+        if (index < 0)
+            return false;
+        list.splice(index, 1, newMessage);
+        return true;
+    }
+    remove(messageId) {
+        const list = this.find(messageId);
+        if (list === undefined)
+            return false;
+        const index = list.findIndex((message) => message.id === messageId);
+        if (index < 0)
+            return false;
+        list.splice(index, 1);
+        return true;
+    }
+    splice(target, start, deleteCount, inserted) {
+        return this.list(target).splice(start, deleteCount, ...inserted);
+    }
+    list(target) {
+        return target === "next-turn" ? this.nextTurnList : this.nextStepList;
+    }
+    find(messageId) {
+        if (this.nextTurnList.some((message) => message.id === messageId))
+            return this.nextTurnList;
+        if (this.nextStepList.some((message) => message.id === messageId))
+            return this.nextStepList;
+        return undefined;
+    }
+}