super-dsh 0.1.9 → 0.1.10

package/agent-omp-sdk/dist/omp-disk-discovery.js

@@ -0,0 +1,178 @@
+/**
+ * Host-side disk readers for OMP slash commands and skills.
+ *
+ * Replaces the sidecar round-trips (`slashCommands.list` / `skills.list`) that
+ * used to spawn the whole bun/OMP core just to walk a few directories. The
+ * upstream discovery (pi-coding-agent src/discovery/*) is a 10+ provider
+ * capability web we deliberately do NOT port; v1 scans the practical roots:
+ *
+ *   commands: <OMP_NATIVE_HOME>/agent/commands/*.md      (native user)
+ *             <cwd>/.omp/commands/*.md                   (native project)
+ *             ~/.claude/commands/*.md                    (claude user)
+ *             <cwd>/.claude/commands/*.md                (claude project)
+ *   skills:   the same four roots' `skills/` sibling, each entry either
+ *             `<root>/<name>/SKILL.md` (Agent Skills standard) or a lenient
+ *             flat `<root>/*.md`.
+ *
+ * Known divergences from the SDK path (accepted, see plan §3): no embedded
+ * bundled commands, no codex/opencode/cursor/gemini providers, no capability
+ * semantics (at-imports, managed skills, extensionRoots reload). Dedupe order
+ * is scan order with FIRST occurrence winning: omp user → claude user →
+ * omp project → claude project. All readers are fail-soft: missing roots or
+ * unreadable files are skipped, never thrown.
+ *
+ * @module agent-omp/omp-disk-discovery
+ */
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { resolveOmpNativeHome } from "./knobs.js";
+function discoveryRoots(cwd, kind) {
+    const home = homedir();
+    const roots = [
+        { base: resolveOmpNativeHome(), subdir: join("agent", kind), label: `omp:user` },
+        { base: home, subdir: join(".claude", kind), label: `claude:user` },
+    ];
+    if (cwd !== undefined && cwd !== "") {
+        roots.push({ base: cwd, subdir: join(".omp", kind), label: `omp:project` }, { base: cwd, subdir: join(".claude", kind), label: `claude:project` });
+    }
+    return roots;
+}
+/**
+ * Split an optional YAML-ish frontmatter from a markdown body and derive the
+ * display description the way the SDK's parseCommandTemplate does: the
+ * frontmatter `description` when present, else the first non-empty body line
+ * trimmed to 60 chars. Unknown keys are ignored; a malformed block degrades to
+ * "whole file is body".
+ */
+function parseMarkdownTemplate(raw) {
+    const text = raw.replace(/\r\n/g, "\n");
+    if (!text.startsWith("---\n")) {
+        return { description: fallbackDescription(text), content: text };
+    }
+    const end = text.indexOf("\n---", 4);
+    if (end === -1) {
+        return { description: fallbackDescription(text), content: text };
+    }
+    const frontmatter = text.slice(4, end);
+    const bodyStart = text.indexOf("\n", end + 1);
+    const body = bodyStart === -1 ? "" : text.slice(bodyStart + 1).replace(/^\n+/, "");
+    let description;
+    for (const line of frontmatter.split("\n")) {
+        const match = /^(description|argument-hint):\s*(.*)$/.exec(line);
+        if (match !== null && match[2] !== "") {
+            description = match[2].trim().replace(/^["']|["']$/g, "");
+            break;
+        }
+    }
+    return { description: description ?? fallbackDescription(body), content: body };
+}
+function fallbackDescription(body) {
+    const line = body.split("\n").find((candidate) => candidate.trim() !== "") ?? "";
+    return line.trim().slice(0, 60);
+}
+function listMarkdownFiles(dir) {
+    try {
+        return readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".md"))
+            .map((entry) => entry.name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+function readFileSoft(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Read every file-based slash command from the discovery roots.
+ * Deterministic output: deduped by name (scan order, first wins), then sorted.
+ */
+export function readSlashCommands(cwd) {
+    const byName = new Map();
+    for (const root of discoveryRoots(cwd, "commands")) {
+        const dir = join(root.base, root.subdir);
+        for (const file of listMarkdownFiles(dir)) {
+            const name = file.replace(/\.md$/i, "");
+            if (name === "" || byName.has(name))
+                continue;
+            const raw = readFileSoft(join(dir, file));
+            if (raw === undefined)
+                continue;
+            const parsed = parseMarkdownTemplate(raw);
+            byName.set(name, {
+                name,
+                description: parsed.description,
+                content: parsed.content,
+                source: root.label,
+                filePath: join(dir, file),
+            });
+        }
+    }
+    return [...byName.values()].sort((left, right) => left.name.localeCompare(right.name));
+}
+function readSkillFile(path, label) {
+    const raw = readFileSoft(path);
+    if (raw === undefined)
+        return undefined;
+    const parsed = parseMarkdownTemplate(raw);
+    // Frontmatter `name:` may rename the skill; default to the directory/file name.
+    let name = "";
+    const frontmatterName = /^---\n[\s\S]*?^name:\s*(\S+)/m.exec(raw);
+    if (frontmatterName !== null)
+        name = frontmatterName[1];
+    if (name === "") {
+        const base = path.split("/").pop() ?? "";
+        name = base.toLowerCase() === "skill.md" ? (path.split("/").at(-2) ?? base) : base.replace(/\.md$/i, "");
+    }
+    return {
+        name,
+        description: parsed.description,
+        filePath: path,
+        baseDir: path.slice(0, path.lastIndexOf("/")) || path,
+        source: label,
+    };
+}
+/**
+ * Read every discovered skill from the discovery roots: the Agent Skills
+ * standard `<root>/<name>/SKILL.md` layout, plus a lenient flat `<root>/*.md`.
+ * Deterministic output: deduped by name (scan order, first wins), then sorted.
+ */
+export function readSkills(cwd) {
+    const byName = new Map();
+    for (const root of discoveryRoots(cwd, "skills")) {
+        const dir = join(root.base, root.subdir);
+        if (!existsSync(dir))
+            continue;
+        let entries = [];
+        try {
+            entries = readdirSync(dir, { withFileTypes: true }).map((entry) => ({
+                name: entry.name,
+                isDirectory: entry.isDirectory(),
+            }));
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const path = entry.isDirectory
+                ? join(dir, entry.name, "SKILL.md")
+                : join(dir, entry.name);
+            if (!entry.isDirectory && !entry.name.toLowerCase().endsWith(".md"))
+                continue;
+            if (entry.isDirectory && byName.has(entry.name))
+                continue;
+            const skill = readSkillFile(path, root.label);
+            if (skill === undefined || byName.has(skill.name))
+                continue;
+            byName.set(skill.name, skill);
+        }
+    }
+    return [...byName.values()].sort((left, right) => left.name.localeCompare(right.name));
+}

package/agent-omp-sdk/dist/omp-executable.d.ts

@@ -0,0 +1,2 @@
+/** `$OMP_EXECUTABLE` wins; else PATH, else the common native-installer spots. */
+export declare function resolveOmpExecutable(): string;

package/agent-omp-sdk/dist/omp-executable.js

@@ -0,0 +1,30 @@
+/**
+ * Locate the operator's `omp` binary — the ONE resolution order the adapter's
+ * data plane (`omp-cli.ts`) uses.
+ *
+ * The SDK line does NOT need this to run its sessions (those live in the
+ * fetched bun sidecar), but the model catalog and the `modelRoles` bridge are
+ * read through the operator's own binary so the two OMP faces agree on config.
+ *
+ * Ported verbatim from the RPC line (`@pgmi-builds/agent-omp`, rpc-client.ts):
+ * a local copy keeps this package standalone — the task ruling is a complete
+ * standalone copy, not a shared-code sibling.
+ */
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** `$OMP_EXECUTABLE` wins; else PATH, else the common native-installer spots. */
+export function resolveOmpExecutable() {
+    const configured = process.env.OMP_EXECUTABLE?.trim();
+    if (configured !== undefined && configured !== "")
+        return configured;
+    for (const dir of (process.env.PATH ?? "").split(":").filter(Boolean)) {
+        if (existsSync(join(dir, "omp")))
+            return "omp";
+    }
+    for (const candidate of [join(homedir(), ".local/bin/omp"), "/usr/local/bin/omp"]) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return "omp";
+}

package/agent-omp-sdk/dist/omp-store.d.ts

@@ -0,0 +1,134 @@
+import type { OmpMessage } from "./rpc-types.js";
+/** One OMP-native session discovered by {@link scanOmpSessions}. */
+export interface OmpNativeSession {
+    /** OMP's session id (the `session` header record's `id`). */
+    readonly ompSessionId: string;
+    /** Absolute path to the OMP session file (the transcript of record). */
+    readonly ompSessionFile: string;
+    /** Working directory recorded in the session header, if any. */
+    readonly cwd?: string;
+    /** Creation epoch ms (session header `timestamp`, filename fallback). */
+    readonly createdAt: number;
+    /** Display title: the title record, else the first user message, else absent. */
+    readonly title?: string;
+    /** Transcript byte size (reconcile change detection). */
+    readonly size: number;
+    /** Transcript mtime, epoch ms (reconcile change detection + default sort). */
+    readonly mtimeMs: number;
+    /** Opaque change token (stat-derived), for persistence snapshot revisions. */
+    readonly revision: string;
+}
+/** Root of OMP's native session store. */
+export declare const OMP_SESSIONS_ROOT: string;
+/** One OMP `model_change` entry from a session transcript. */
+export interface OmpModelChange {
+    /** `provider/model` selector string. */
+    readonly model: string;
+    /** The role this change records (absent on the initial restore). */
+    readonly role?: string;
+}
+/** The two record families cold replay needs from one transcript read. */
+export interface OmpTranscript {
+    messages: OmpMessage[];
+    modelChanges: OmpModelChange[];
+}
+/**
+ * Read one OMP session transcript in a single pass, extracting both the
+ * `message` records and the `model_change` records.
+ */
+export declare function readOmpTranscript(path: string): OmpTranscript;
+/**
+ * Legacy fallback: the last assistant message that names a provider/model
+ * pair. Used only for transcripts without any `model_change` record; newer
+ * sessions derive their resume model from {@link lastRestorableModel}.
+ */
+export declare function lastModelCall(messages: OmpMessage[]): {
+    provider: string;
+    model: string;
+} | undefined;
+/** Split a `provider/model[:variant]` selector into provider/model, dropping the variant suffix. */
+export declare function parseSelector(selector: string | undefined): {
+    provider: string;
+    model: string;
+} | undefined;
+/**
+ * The model OMP restores on `--resume`: the last non-fallback `model_change`.
+ * Mirrors OMP's `getRestorableSessionModels` (`session-context.ts`): a
+ * fallback switch is recorded under `role:"fallback"` (EPHEMERAL) and never
+ * restores — the last such switch falls back to the role's primary.
+ */
+export declare function lastRestorableModel(modelChanges: OmpModelChange[]): {
+    provider: string;
+    model: string;
+} | undefined;
+/**
+ * Read the whole `modelRoles` map (role → "provider/model[:effort]") from
+ * OMP's config.yml. Returns undefined when the block is absent/empty or the
+ * file is unreadable. A deliberately minimal YAML scan — the bridge has no
+ * YAML dependency; one indent level of `key: value` lines inside the block.
+ */
+export declare function readOmpModelRolesFromConfig(): Record<string, string> | undefined;
+/**
+ * Read the configured default role model (`modelRoles.default`) from OMP's
+ * config.yml. Returns the provider/model pair (variant suffix dropped), or
+ * undefined when unset or unreadable. Delegates to the whole-map reader.
+ */
+export declare function readOmpDefaultModelFromConfig(): {
+    provider: string;
+    model: string;
+} | undefined;
+/**
+ * Derive the working directory a session ran in from its location in OMP's
+ * store: the parent directory name is the cwd with every "/" flattened to
+ * "-" (leading "/" → leading "-"). Literal dashes in path segments are
+ * ambiguous, so segments are re-joined greedily longest-first against the
+ * filesystem and the candidate is accepted only as an existing directory
+ * (realpath'd). This is the trusted resume cwd — the omp-sessions.json
+ * mapping's verbatim `cwd` is user-writable and never consulted.
+ */
+export declare function cwdFromSessionFile(path: string): string | undefined;
+/** Read one session file's header id (the `session` record's `id`), no full scan. */
+export declare function sessionHeaderId(path: string): string | undefined;
+/**
+
+/**
+ * Scan OMP's native store (PURE DISK — sidecar-free). Returns sessions keyed
+ * by OMP session id; files without a parsable `session` header record are
+ * skipped (corrupt/foreign).
+ *
+ * The FILE LIST always comes from a fresh directory walk; per-session metadata
+ * (id/cwd/title/createdAt) comes from the self-written {@link scanHead},
+ * memoized by size+mtime in `entryCache`. The old SDK `sessions.listAll` fast
+ * path is GONE (sidecar-decoupling): the only consumer left is pairing.ts's
+ * store-absent fallback (unit tests).
+ */
+export declare function scanOmpSessions(): Map<string, OmpNativeSession>;
+/**
+ * One /proc pass over every foreign process's write-mode file descriptors,
+ * returning `canonical path → first foreign writer pid`. Shared by every
+ * session in one tick so the daemon never re-scans /proc per file.
+ *
+ * OMP has no session-level exclusivity: neither the TUI nor `--mode rpc`
+ * locks its transcript, so two live writers interleave appends silently
+ * (verified: a TUI `omp` and a bridge `omp --mode rpc --resume` coexisted on
+ * one file with plain `w` descriptors and no advisory locks). The intended
+ * enforcement is to refuse resuming a transcript another process already writes
+ * (the TUI case), closing the split-brain at the only layer that can see it —
+ * but see {@link foreignWriterPid}: that hold is NOT wired in this round.
+ * Own descendants (a just-torn-down bridge child whose fds linger) are
+ * exempt to keep teardown races from wedging re-resume.
+ */
+export declare function scanForeignWriters(): Map<string, number>;
+/**
+ * Pid of a FOREIGN process holding `file` open for writing, if any.
+ * Convenience wrapper over {@link scanForeignWriters} for the single-file
+ * resume gate.
+ *
+ * UNWIRED (2026-10-03): this helper has no caller — the `resume` path never
+ * invokes it, so nothing currently refuses a transcript another process (the
+ * TUI) is writing. Spec §3.4 of `docs/specs/omp-rpc-transport/spec.md`
+ * registers that accepted exposure and the planned follow-up: a fail-loud
+ * `foreignWriterPid(<sessionFile>)` check wired into `resume`, to be decided
+ * by the operator. Helper kept exported for that follow-up.
+ */
+export declare function foreignWriterPid(file: string): number | undefined;