wyrm-mcp 7.3.2 → 7.3.3

package/dist/spec-kit.js

@@ -1 +1,191 @@
-import{readFileSync as h,existsSync as g}from"fs";import{join as k}from"path";function b(a){const s=a.split(/\r?\n/);let c,r;for(const t of s){const e=t.match(/^#\s+(.+?)\s*$/);if(e){c=e[1].trim();break}const i=t.match(/^\s*(?:title|feature|name)\s*[:=]\s*(.+?)\s*$/i);if(i){c=i[1].trim();break}}const l=s.findIndex(t=>/^#{1,6}\s+(summary|overview|description)\b/i.test(t));if(l>=0){const t=[];for(let e=l+1;e<s.length;e++){const i=s[e];if(/^#{1,6}\s+/.test(i)||i.trim()===""&&t.length)break;i.trim()!==""&&t.push(i.trim())}t.length&&(r=t.join(" ").trim())}if(!r){const t=[];for(const e of s){if(/^#{1,6}\s+/.test(e)){if(t.length)break;continue}if(e.trim()===""){if(t.length)break;continue}if(/^\s*[-*]\s*\[/.test(e)){if(t.length)break;continue}t.push(e.trim())}t.length&&(r=t.join(" ").trim())}return{title:c,summary:r}}function $(a){const s=[],c=a.split(/\r?\n/);let r=!1,l=0;for(const t of c){const i=t.replace(/\s+$/,"").trim();if(/^```/.test(i)){r=!r;continue}if(r||i===""||/^#{1,6}\s+/.test(i))continue;let n="",d=!1,f=!1;const u=i.match(/^[-*+]\s*\[([ xX])\]\s*(.+)$/);if(u&&(d=u[1].toLowerCase()==="x",n=u[2].trim(),f=!0),!f){const o=i.match(/^\d+[.)]\s+(.+)$/);o&&(n=o[1].trim(),f=!0)}if(!f){const o=i.match(/^(T\d{1,4})[\s:.)-]+(.+)$/i);o&&(n=`${o[1].toUpperCase()} ${o[2].trim()}`,f=!0)}if(!f){const o=i.match(/^[-*+]\s+(.+)$/);o&&/[a-zA-Z]/.test(o[1])&&(n=o[1].trim(),f=!0)}if(!f||n==="")continue;l++;let m;const p=n.match(/^(T\d{1,4})\b[\s:.)-]*/i);p?(m=p[1].toUpperCase(),n=n.slice(p[0].length).trim()):m=`L${String(l).padStart(3,"0")}`,n=n.replace(/^\[[A-Za-z0-9]{1,3}\]\s*/,"").trim(),n===""&&(n=m),s.push({id:m,title:n,done:d,ordinal:l})}return s}function y(a){const s=k(a,"spec.md"),c=k(a,"tasks.md");let r,l;if(g(s)){const e=b(h(s,"utf-8"));r=e.title,l=e.summary}let t=[];return g(c)&&(t=$(h(c,"utf-8"))),{title:r,summary:l,tasks:t}}function S(a,s){return`spec:${(a.replace(/[\\/]+$/,"").split(/[\\/]/).pop()||a).toLowerCase().replace(/[^a-z0-9]+/g,"-").replace(/^-+|-+$/g,"")}:${s.toLowerCase()}`}export{b as parseSpecMarkdown,$ as parseTasksMarkdown,y as readSpecDir,S as specTaskSignature};
+/**
+ * Wyrm spec-kit registry — GHOSTMESH spec-kit specs → Wyrm-native quests.
+ *
+ * Parses the spec-kit document layout (spec.md / tasks.md) into structured data
+ * the wyrm_spec_register tool turns into idempotent quests. Pure functions +
+ * filesystem reads only — no DB coupling, so it's trivially unit-testable.
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+/**
+ * Extract a title + summary from a spec.md body.
+ *  - title: first markdown H1 (`# ...`) or, failing that, a `Title:`/`Feature:` field.
+ *  - summary: first `## Summary`/`## Overview` paragraph, else the first non-heading
+ *    prose paragraph.
+ */
+export function parseSpecMarkdown(md) {
+    const lines = md.split(/\r?\n/);
+    let title;
+    let summary;
+    for (const line of lines) {
+        const h1 = line.match(/^#\s+(.+?)\s*$/);
+        if (h1) {
+            title = h1[1].trim();
+            break;
+        }
+        const field = line.match(/^\s*(?:title|feature|name)\s*[:=]\s*(.+?)\s*$/i);
+        if (field) {
+            title = field[1].trim();
+            break;
+        }
+    }
+    // Summary: prefer the paragraph under a Summary/Overview/Description heading.
+    const headingIdx = lines.findIndex((l) => /^#{1,6}\s+(summary|overview|description)\b/i.test(l));
+    if (headingIdx >= 0) {
+        const para = [];
+        for (let i = headingIdx + 1; i < lines.length; i++) {
+            const l = lines[i];
+            if (/^#{1,6}\s+/.test(l))
+                break; // next heading ends the section
+            if (l.trim() === '' && para.length)
+                break; // blank line ends the first paragraph
+            if (l.trim() !== '')
+                para.push(l.trim());
+        }
+        if (para.length)
+            summary = para.join(' ').trim();
+    }
+    // Fallback: first non-heading, non-blank prose paragraph.
+    if (!summary) {
+        const para = [];
+        for (const l of lines) {
+            if (/^#{1,6}\s+/.test(l)) {
+                if (para.length)
+                    break;
+                else
+                    continue;
+            }
+            if (l.trim() === '') {
+                if (para.length)
+                    break;
+                else
+                    continue;
+            }
+            if (/^\s*[-*]\s*\[/.test(l)) {
+                if (para.length)
+                    break;
+                else
+                    continue;
+            } // skip task lines
+            para.push(l.trim());
+        }
+        if (para.length)
+            summary = para.join(' ').trim();
+    }
+    return { title, summary };
+}
+/**
+ * Parse a tasks.md into a flat ordered task list. Recognizes the common
+ * spec-kit / markdown task encodings:
+ *   - `T001 Do the thing`                (id-prefixed)
+ *   - `- [ ] Do the thing`               (gfm checkbox, open)
+ *   - `- [x] Do the thing`               (gfm checkbox, done)
+ *   - `- [ ] T012 [P] Do the thing`      (checkbox + id + parallel marker)
+ *   - `1. Do the thing`                  (numbered list)
+ *   - `- Do the thing`                   (plain bullet)
+ * Headings, blank lines, code fences, and non-task prose are ignored.
+ */
+export function parseTasksMarkdown(md) {
+    const tasks = [];
+    const lines = md.split(/\r?\n/);
+    let inFence = false;
+    let ordinal = 0;
+    for (const raw of lines) {
+        const line = raw.replace(/\s+$/, '');
+        const trimmed = line.trim();
+        if (/^```/.test(trimmed)) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence)
+            continue;
+        if (trimmed === '')
+            continue;
+        if (/^#{1,6}\s+/.test(trimmed))
+            continue; // headings are sections, not tasks
+        let body = '';
+        let done = false;
+        let matched = false;
+        // 1) GFM checkbox bullet: - [ ] / - [x] / * [X]
+        const cb = trimmed.match(/^[-*+]\s*\[([ xX])\]\s*(.+)$/);
+        if (cb) {
+            done = cb[1].toLowerCase() === 'x';
+            body = cb[2].trim();
+            matched = true;
+        }
+        // 2) Numbered list: 1. text   or   1) text
+        if (!matched) {
+            const num = trimmed.match(/^\d+[.)]\s+(.+)$/);
+            if (num) {
+                body = num[1].trim();
+                matched = true;
+            }
+        }
+        // 3) Bare id-prefixed task: T001 text  (also catches "T001: text", "T001. text")
+        if (!matched) {
+            const idline = trimmed.match(/^(T\d{1,4})[\s:.)-]+(.+)$/i);
+            if (idline) {
+                body = `${idline[1].toUpperCase()} ${idline[2].trim()}`;
+                matched = true;
+            }
+        }
+        // 4) Plain bullet: - text  (only when it looks like a task, i.e. has letters)
+        if (!matched) {
+            const bullet = trimmed.match(/^[-*+]\s+(.+)$/);
+            if (bullet && /[a-zA-Z]/.test(bullet[1])) {
+                body = bullet[1].trim();
+                matched = true;
+            }
+        }
+        if (!matched || body === '')
+            continue;
+        ordinal++;
+        // Pull out a leading task id if present (e.g. "T001 [P] do x" → id T001).
+        let id;
+        const idMatch = body.match(/^(T\d{1,4})\b[\s:.)-]*/i);
+        if (idMatch) {
+            id = idMatch[1].toUpperCase();
+            body = body.slice(idMatch[0].length).trim();
+        }
+        else {
+            id = `L${String(ordinal).padStart(3, '0')}`;
+        }
+        // Strip a leading [P]/[X] parallel/phase marker that spec-kit sometimes uses.
+        body = body.replace(/^\[[A-Za-z0-9]{1,3}\]\s*/, '').trim();
+        if (body === '')
+            body = id;
+        tasks.push({ id, title: body, done, ordinal });
+    }
+    return tasks;
+}
+/** Read + parse a spec directory. Tolerant of missing spec.md (title/summary become undefined). */
+export function readSpecDir(specDir) {
+    const specPath = join(specDir, 'spec.md');
+    const tasksPath = join(specDir, 'tasks.md');
+    let title;
+    let summary;
+    if (existsSync(specPath)) {
+        const meta = parseSpecMarkdown(readFileSync(specPath, 'utf-8'));
+        title = meta.title;
+        summary = meta.summary;
+    }
+    let tasks = [];
+    if (existsSync(tasksPath)) {
+        tasks = parseTasksMarkdown(readFileSync(tasksPath, 'utf-8'));
+    }
+    return { title, summary, tasks };
+}
+/**
+ * Deterministic dedupe signature for a spec task. Combines a slug of the spec
+ * directory (basename) with the task id so re-running spec_register matches the
+ * same quest by tag instead of creating a duplicate.
+ */
+export function specTaskSignature(specDir, taskId) {
+    const base = specDir.replace(/[\\/]+$/, '').split(/[\\/]/).pop() || specDir;
+    const slug = base.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+    return `spec:${slug}:${taskId.toLowerCase()}`;
+}
+//# sourceMappingURL=spec-kit.js.map

package/dist/sqlite-busy.js

@@ -1 +1,154 @@
-import{renderErrorResponse as o}from"./render.js";const n="WYRM_BUSY",i="WYRM_CIRCUIT_OPEN",s="WYRM_DAEMON_AMBIGUOUS",a=1e3,c=3e4;function u(e){if(e===null||typeof e!="object")return!1;const t=e.code;return typeof t=="string"&&t.startsWith("SQLITE_BUSY")}function p(e){if(e===null||typeof e!="object")return!1;const t=e.code;return typeof t=="string"&&t.startsWith("SQLITE_CONSTRAINT")}function _(e){if(u(e))return"lock";if(e===null||typeof e!="object")return null;const t=e.code;return t===i?"circuit":t===s?"daemon":null}function d(e,t="lock"){const r=t==="circuit"?`${e}: the Wyrm write path's circuit breaker is open after repeated write failures (WYRM_CIRCUIT_OPEN); writes are refused until it half-opens (~30s).`:t==="daemon"?`${e}: the daemon write outcome is unknown (WYRM_DAEMON_WRITES=1 and the daemon stopped responding mid-write); the local fallback was withheld to avoid a duplicate row.`:`${e}: the Wyrm database is briefly write-locked by another process (SQLITE_BUSY \u2014 the cross-process write lock outlived the busy_timeout grace window, or a read-then-write transaction lost a snapshot upgrade race).`;return{error:{code:n,message:r,retryable:!0,retry_after_ms:t==="circuit"?c:a},expected:`Retry the SAME ${e} call with the SAME arguments after retry_after_ms; no arguments need to change. Retrying is safe: writes are transactional or coalesce by key (a retried failure_record may count one extra occurrence by design`+(t==="daemon"?"; forwarded writes reuse their idempotency key inside the retry window, so the daemon cannot apply the write twice":"")+")."}}function f(e,t="lock"){return o(d(e,t))}export{a as BUSY_RETRY_AFTER_MS,c as CIRCUIT_RETRY_AFTER_MS,n as WYRM_BUSY_CODE,i as WYRM_CIRCUIT_OPEN_CODE,s as WYRM_DAEMON_AMBIGUOUS_CODE,d as busyErrorBody,f as busyErrorResponse,u as isSqliteBusyError,p as isSqliteConstraintError,_ as retryableWriteCause};
+/**
+ * Cross-process write story (v7 F2, T011) — the SQLITE_BUSY boundary.
+ *
+ * WHAT THIS IS: when two OS PROCESSES (an MCP server + the HTTP daemon, or two
+ * fleet subagent processes) share one wyrm.db, SQLite's WAL mode allows many
+ * readers but exactly ONE writer at a time. A contended writer spins inside
+ * SQLite for `busy_timeout` (5000ms, set + documented in database.ts) and only
+ * then surfaces SQLITE_BUSY. Before T011 that escaped the dispatcher as an
+ * opaque `Error: SqliteError: database is locked` string — a structured-output
+ * subagent reading that has no machine-readable signal that the write is
+ * RETRYABLE, so fleets abandoned writes that one retry would have landed.
+ *
+ * This module owns the classification + the structured SEP-1303-style error
+ * body (`isError: true` + `{error, expected}`, the same framing spec FR-3
+ * standardizes for validation errors) so subagents self-correct: parse
+ * `error.code === 'WYRM_BUSY'`, wait `retry_after_ms`, retry the SAME call.
+ *
+ * WHY THERE IS NO IN-PROCESS WRITE QUEUE: better-sqlite3 is fully synchronous —
+ * two writes issued by the SAME process can never interleave by construction
+ * (each `run()` completes before the next statement starts), so an in-process
+ * queue would serialize something that is already serial. The only real
+ * contention is CROSS-process, and that is handled by (a) busy_timeout giving
+ * the writer a 5s grace window, (b) WyrmDB.batchWrites() — the transaction
+ * helper the batched insert path commits through (WyrmDB.insertDataBatch,
+ * behind wyrm_data_batch_insert) — taking the write lock once per batch
+ * instead of once per row, and (c) this structured BUSY/RETRY body when the
+ * window is exceeded.
+ *
+ * Article III: zero LLM involvement — classification is a string check on the
+ * better-sqlite3 error code; the retry hint is a fixed documented constant.
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+import { renderErrorResponse } from './render.js';
+/** Machine-readable error code subagents key their retry logic on. */
+export const WYRM_BUSY_CODE = 'WYRM_BUSY';
+/** v7 F2 review fix: ResilienceManager's circuit breaker refuses writes while
+ * open. The error it returns now carries this code so the dispatcher can map
+ * it to the SAME structured retryable body instead of an opaque plain Error
+ * (previously the breaker, once tripped, made the WYRM_BUSY body unreachable
+ * for its whole 30s window — exactly during sustained contention). */
+export const WYRM_CIRCUIT_OPEN_CODE = 'WYRM_CIRCUIT_OPEN';
+/** v7 F2 review fix: a daemon-forwarded write (WYRM_DAEMON_WRITES=1) whose
+ * outcome is UNKNOWN — the request may have been delivered and committed but
+ * no response arrived. daemon-writer.ts throws this instead of silently
+ * falling back to a local direct write (which could double-write canonical
+ * memory — Article VI). Retrying the same call is safe: the forwarded write
+ * reuses its idempotency key (within the pending-breadcrumb TTL), so the
+ * daemon cannot apply it twice. Bounded: after DAEMON_AMBIGUOUS_CYCLE_CAP
+ * consecutive ambiguous cycles daemon-writer.ts throws a NON-retryable
+ * WYRM_DAEMON_RETRY_EXHAUSTED instead — deliberately unclassified by
+ * retryableWriteCause, so a persistently failing daemon surfaces loudly
+ * rather than holding callers in an instructed-retry loop. */
+export const WYRM_DAEMON_AMBIGUOUS_CODE = 'WYRM_DAEMON_AMBIGUOUS';
+/**
+ * Retry spacing advice (ms). Rationale: by the time SQLITE_BUSY surfaces the
+ * caller has ALREADY waited the full 5000ms busy_timeout inside SQLite, so the
+ * lock holder is a genuinely long-running writer (bulk import, vacuum,
+ * checkpoint), not a sub-millisecond row write. 1s spacing keeps a retrying
+ * fleet responsive without a thundering herd of immediate re-attempts that
+ * would each burn another 5s busy_timeout window. This is advice to the
+ * caller, not a measured performance claim (Article VIII).
+ */
+export const BUSY_RETRY_AFTER_MS = 1000;
+/** Circuit-open retry spacing: the breaker half-opens after its 30s timeout
+ * (resilience.ts DEFAULT_CIRCUIT_CONFIG.timeout) — advising a 1s retry would
+ * just bounce off the still-open breaker 29 more times. */
+export const CIRCUIT_RETRY_AFTER_MS = 30_000;
+/**
+ * True when `err` is a better-sqlite3 SQLITE_BUSY family error
+ * (SQLITE_BUSY, SQLITE_BUSY_SNAPSHOT, SQLITE_BUSY_RECOVERY, ...).
+ * Deliberately NOT matching SQLITE_LOCKED: that is same-connection /
+ * shared-cache contention — a programming error, not a retryable
+ * cross-process race — and must stay loud.
+ */
+export function isSqliteBusyError(err) {
+    if (err === null || typeof err !== 'object')
+        return false;
+    const code = err.code;
+    return typeof code === 'string' && code.startsWith('SQLITE_BUSY');
+}
+/**
+ * True when `err` is a better-sqlite3 SQLITE_CONSTRAINT family error
+ * (SQLITE_CONSTRAINT_CHECK, _FOREIGNKEY, _UNIQUE, _NOTNULL, ...). These are
+ * DETERMINISTIC domain rejections: every daemon write op is a single
+ * statement or one IMMEDIATE transaction, so a constraint throw PROVES the
+ * write rolled back without committing. The daemon write endpoint maps this
+ * family to the rejected `{e}` wire shape — the client fails direct and the
+ * real constraint message surfaces through the local path — instead of a
+ * generic 500, which the client must treat as commit-state-unknown and would
+ * otherwise retry forever (the same inputs deterministically re-violate).
+ * Deliberately NOT widened to all non-BUSY errors: a post-commit throw also
+ * 5xxs on a COMMITTED row, and claiming "no commit" for it double-writes.
+ */
+export function isSqliteConstraintError(err) {
+    if (err === null || typeof err !== 'object')
+        return false;
+    const code = err.code;
+    return typeof code === 'string' && code.startsWith('SQLITE_CONSTRAINT');
+}
+export function retryableWriteCause(err) {
+    if (isSqliteBusyError(err))
+        return 'lock';
+    if (err === null || typeof err !== 'object')
+        return null;
+    const code = err.code;
+    if (code === WYRM_CIRCUIT_OPEN_CODE)
+        return 'circuit';
+    if (code === WYRM_DAEMON_AMBIGUOUS_CODE)
+        return 'daemon';
+    return null;
+}
+/**
+ * v7 F2 review fix — the `expected` contract no longer overclaims "Nothing was
+ * written": multi-statement handlers exist (failure_record's record-then-
+ * promote sequence), and an ambiguous daemon outcome may have committed
+ * remotely. The honest, still machine-actionable contract: retrying the SAME
+ * call is SAFE — statement groups are transactional (failures.record() and
+ * audit appends run in one IMMEDIATE transaction), coalescing writes coalesce
+ * by key (a re-recorded failure may count one extra occurrence, the documented
+ * accrual-by-design), and daemon-forwarded writes reuse their idempotency key.
+ */
+export function busyErrorBody(tool, cause = 'lock') {
+    const message = cause === 'circuit'
+        ? `${tool}: the Wyrm write path's circuit breaker is open after repeated write failures (WYRM_CIRCUIT_OPEN); writes are refused until it half-opens (~30s).`
+        : cause === 'daemon'
+            ? `${tool}: the daemon write outcome is unknown (WYRM_DAEMON_WRITES=1 and the daemon stopped responding mid-write); the local fallback was withheld to avoid a duplicate row.`
+            : `${tool}: the Wyrm database is briefly write-locked by another process (SQLITE_BUSY — the cross-process write lock outlived the busy_timeout grace window, or a read-then-write transaction lost a snapshot upgrade race).`;
+    return {
+        error: {
+            code: WYRM_BUSY_CODE,
+            message,
+            retryable: true,
+            retry_after_ms: cause === 'circuit' ? CIRCUIT_RETRY_AFTER_MS : BUSY_RETRY_AFTER_MS,
+        },
+        expected: `Retry the SAME ${tool} call with the SAME arguments after retry_after_ms; no arguments need to change. ` +
+            `Retrying is safe: writes are transactional or coalesce by key (a retried failure_record may count one extra occurrence by design` +
+            (cause === 'daemon' ? '; forwarded writes reuse their idempotency key inside the retry window, so the daemon cannot apply the write twice' : '') +
+            `).`,
+    };
+}
+/**
+ * The full MCP tool response for a BUSY write: `content[0].text` is the JSON
+ * serialization of the SAME body that rides in `structuredContent`, so
+ * text-parsing and structured clients see one truth that cannot drift.
+ * v7 F3 (T019): the dual emit goes through the single renderer (render.ts) —
+ * byte-identical to the hand-rolled pre-T019 output, now derived in exactly
+ * one place.
+ */
+export function busyErrorResponse(tool, cause = 'lock') {
+    return renderErrorResponse(busyErrorBody(tool, cause));
+}
+//# sourceMappingURL=sqlite-busy.js.map