framein 0.0.4 → 0.0.5

package/dist/managedBlock.js

@@ -1,101 +1,101 @@
-// Managed-block upsert: framein owns only the region between its markers.
-// Everything a user writes outside the markers is preserved across re-projection.
-//
-// Robustness (see codex review): markers are matched as EXACT FULL LINES, malformed
-// states (dangling / reversed / duplicate markers) are cleaned to a single canonical
-// block without losing user text, and marker strings that appear inside the core data
-// are defanged so they can never be mistaken for real markers.
-export const MANAGED_BEGIN = '<!-- framein:begin — managed by `frame`; edits inside are overwritten. Source: .frame/store.db -->';
-export const MANAGED_END = '<!-- framein:end -->';
-function isMarker(line, marker) {
-    return line.trim() === marker;
-}
-/** Neutralize any core line that IS exactly a marker, so it cannot be parsed as one. */
-function defangMarkerLines(core) {
-    return core.split('\n').map((ln) => {
-        const t = ln.trim();
-        return t === MANAGED_BEGIN || t === MANAGED_END ? ln.replace('<!--', '&lt;!--') : ln;
-    }).join('\n');
-}
-/** Wrap the core block in the managed markers. Identical across all three files. */
-export function wrapManaged(coreBlock) {
-    return `${MANAGED_BEGIN}\n${defangMarkerLines(coreBlock)}\n${MANAGED_END}`;
-}
-/** All well-formed [begin,end] line-index regions, paired greedily. */
-function findRegions(lines) {
-    const regions = [];
-    let i = 0;
-    while (i < lines.length) {
-        if (isMarker(lines[i], MANAGED_BEGIN)) {
-            let j = i + 1;
-            while (j < lines.length && !isMarker(lines[j], MANAGED_END))
-                j++;
-            if (j < lines.length) {
-                regions.push([i, j]);
-                i = j + 1;
-                continue;
-            }
-        }
-        i++;
-    }
-    return regions;
-}
-/** Count of lines that are exactly a begin or end marker. */
-function markerLineCount(lines) {
-    return lines.filter((l) => isMarker(l, MANAGED_BEGIN) || isMarker(l, MANAGED_END)).length;
-}
-/** Remove every well-formed managed region and any stray marker lines; preserve the rest. */
-export function stripManagedBlocks(content) {
-    const lines = content.split('\n');
-    const out = [];
-    for (let i = 0; i < lines.length; i++) {
-        if (isMarker(lines[i], MANAGED_BEGIN)) {
-            let j = i + 1;
-            while (j < lines.length && !isMarker(lines[j], MANAGED_END))
-                j++;
-            if (j < lines.length) {
-                i = j;
-                continue;
-            } // drop a full region
-            continue; // dangling begin: drop just this line
-        }
-        if (isMarker(lines[i], MANAGED_END))
-            continue; // stray end: drop just this line
-        out.push(lines[i]);
-    }
-    return out.join('\n');
-}
-/** The single well-formed managed region (markers inclusive), or null. */
-export function extractManagedBlock(content) {
-    const lines = content.split('\n');
-    const regions = findRegions(lines);
-    if (regions.length === 0)
-        return null;
-    const [b, e] = regions[0];
-    return lines.slice(b, e + 1).join('\n');
-}
-/**
- * Insert or replace the managed block in `existing`, preserving everything outside it.
- *
- * - null/empty existing            → fresh file: `# <title>` heading + the managed block.
- * - exactly one clean region       → replace it IN PLACE (outside bytes preserved exactly).
- * - malformed (dangling/reversed/duplicate/stray markers) → clean all of them and append a
- *   single canonical block; subsequent runs see one clean region and are fully idempotent.
- *
- * `managed` must be the output of wrapManaged() (markers included).
- */
-export function upsertManagedBlock(existing, title, managed) {
-    if (existing == null || existing.trim() === '') {
-        return `# ${title}\n\n${managed}\n`;
-    }
-    const lines = existing.split('\n');
-    const regions = findRegions(lines);
-    const healthySingle = regions.length === 1 && markerLineCount(lines) === 2;
-    if (healthySingle) {
-        const [b, e] = regions[0];
-        return [...lines.slice(0, b), ...managed.split('\n'), ...lines.slice(e + 1)].join('\n');
-    }
-    // malformed or empty-of-user-text: rebuild cleanly without losing content
-    const body = stripManagedBlocks(existing).replace(/\s*$/, '');
-    return `${body === '' ? `# ${title}` : body}\n\n${managed}\n`;
-}
+// Managed-block upsert: framein owns only the region between its markers.
+// Everything a user writes outside the markers is preserved across re-projection.
+//
+// Robustness (see codex review): markers are matched as EXACT FULL LINES, malformed
+// states (dangling / reversed / duplicate markers) are cleaned to a single canonical
+// block without losing user text, and marker strings that appear inside the core data
+// are defanged so they can never be mistaken for real markers.
+export const MANAGED_BEGIN = '<!-- framein:begin — managed by `frame`; edits inside are overwritten. Source: .frame/store.db -->';
+export const MANAGED_END = '<!-- framein:end -->';
+function isMarker(line, marker) {
+    return line.trim() === marker;
+}
+/** Neutralize any core line that IS exactly a marker, so it cannot be parsed as one. */
+function defangMarkerLines(core) {
+    return core.split('\n').map((ln) => {
+        const t = ln.trim();
+        return t === MANAGED_BEGIN || t === MANAGED_END ? ln.replace('<!--', '&lt;!--') : ln;
+    }).join('\n');
+}
+/** Wrap the core block in the managed markers. Identical across all three files. */
+export function wrapManaged(coreBlock) {
+    return `${MANAGED_BEGIN}\n${defangMarkerLines(coreBlock)}\n${MANAGED_END}`;
+}
+/** All well-formed [begin,end] line-index regions, paired greedily. */
+function findRegions(lines) {
+    const regions = [];
+    let i = 0;
+    while (i < lines.length) {
+        if (isMarker(lines[i], MANAGED_BEGIN)) {
+            let j = i + 1;
+            while (j < lines.length && !isMarker(lines[j], MANAGED_END))
+                j++;
+            if (j < lines.length) {
+                regions.push([i, j]);
+                i = j + 1;
+                continue;
+            }
+        }
+        i++;
+    }
+    return regions;
+}
+/** Count of lines that are exactly a begin or end marker. */
+function markerLineCount(lines) {
+    return lines.filter((l) => isMarker(l, MANAGED_BEGIN) || isMarker(l, MANAGED_END)).length;
+}
+/** Remove every well-formed managed region and any stray marker lines; preserve the rest. */
+export function stripManagedBlocks(content) {
+    const lines = content.split('\n');
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (isMarker(lines[i], MANAGED_BEGIN)) {
+            let j = i + 1;
+            while (j < lines.length && !isMarker(lines[j], MANAGED_END))
+                j++;
+            if (j < lines.length) {
+                i = j;
+                continue;
+            } // drop a full region
+            continue; // dangling begin: drop just this line
+        }
+        if (isMarker(lines[i], MANAGED_END))
+            continue; // stray end: drop just this line
+        out.push(lines[i]);
+    }
+    return out.join('\n');
+}
+/** The single well-formed managed region (markers inclusive), or null. */
+export function extractManagedBlock(content) {
+    const lines = content.split('\n');
+    const regions = findRegions(lines);
+    if (regions.length === 0)
+        return null;
+    const [b, e] = regions[0];
+    return lines.slice(b, e + 1).join('\n');
+}
+/**
+ * Insert or replace the managed block in `existing`, preserving everything outside it.
+ *
+ * - null/empty existing            → fresh file: `# <title>` heading + the managed block.
+ * - exactly one clean region       → replace it IN PLACE (outside bytes preserved exactly).
+ * - malformed (dangling/reversed/duplicate/stray markers) → clean all of them and append a
+ *   single canonical block; subsequent runs see one clean region and are fully idempotent.
+ *
+ * `managed` must be the output of wrapManaged() (markers included).
+ */
+export function upsertManagedBlock(existing, title, managed) {
+    if (existing == null || existing.trim() === '') {
+        return `# ${title}\n\n${managed}\n`;
+    }
+    const lines = existing.split('\n');
+    const regions = findRegions(lines);
+    const healthySingle = regions.length === 1 && markerLineCount(lines) === 2;
+    if (healthySingle) {
+        const [b, e] = regions[0];
+        return [...lines.slice(0, b), ...managed.split('\n'), ...lines.slice(e + 1)].join('\n');
+    }
+    // malformed or empty-of-user-text: rebuild cleanly without losing content
+    const body = stripManagedBlocks(existing).replace(/\s*$/, '');
+    return `${body === '' ? `# ${title}` : body}\n\n${managed}\n`;
+}

package/dist/mcpRegister.js

@@ -1,85 +1,85 @@
-// Apply step of the MCP registration flow (§6.3: detect -> propose -> APPLY approved -> verify).
-// Pure, idempotent config-merge writers that ADD framein's own MCP server into each CLI's config
-// without clobbering anything else (same safety contract as managedBlock, ADR-0007 B-1). The
-// actual file write + live `claude mcp list` spawn live in cli.ts; only the parser below is pure.
-// Zero-dep: JSON via JSON.parse/stringify, TOML via a line-based text merge (no TOML serializer).
-/** framein registers itself as a subprocess MCP server each CLI launches (ADR-0007). */
-export const FRAMEIN_ENTRY = { command: 'framein', args: ['mcp', 'serve'] };
-/**
- * Pick the spawn command the agent CLIs should use to launch framein's MCP server: the canonical
- * `framein` bin when it's on PATH (installed product), else `node <abs cli.js>` (dev / not globally
- * installed). The agent spawns this verbatim, so it MUST resolve to a real executable.
- */
-export function resolveFrameinEntry(frameOnPath, cliPath) {
-    return frameOnPath ? { command: 'framein', args: ['mcp', 'serve'] } : { command: 'node', args: [cliPath, 'mcp', 'serve'] };
-}
-/**
- * Merge `mcpServers.<name>` into a JSON config (Claude `.mcp.json`, Gemini `settings.json`),
- * preserving every other key and server. Idempotent. Reformats with 2-space indent.
- */
-export function applyJsonMcp(existing, name = 'framein', entry = FRAMEIN_ENTRY) {
-    let root = {};
-    if (existing && existing.trim()) {
-        const parsed = JSON.parse(existing);
-        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
-            root = parsed;
-    }
-    const prev = root.mcpServers;
-    const servers = prev && typeof prev === 'object' && !Array.isArray(prev) ? prev : {};
-    servers[name] = { command: entry.command, args: entry.args };
-    root.mcpServers = servers;
-    return JSON.stringify(root, null, 2) + '\n';
-}
-/**
- * Merge a `[mcp_servers.<name>]` table into a Codex `config.toml` as text: replace the existing
- * block (header line through the next table header / EOF) if present, else append. Idempotent.
- * Preserves all other content; only the framein table is rewritten.
- */
-export function applyCodexMcp(existing, name = 'framein', entry = FRAMEIN_ENTRY) {
-    const header = `[mcp_servers.${name}]`;
-    const block = [
-        header,
-        `command = ${JSON.stringify(entry.command)}`,
-        `args = [${entry.args.map((a) => JSON.stringify(a)).join(', ')}]`,
-    ];
-    const text = existing ?? '';
-    const lines = text.split('\n');
-    const start = lines.findIndex((l) => l.trim() === header);
-    if (start === -1) {
-        const base = text.trim();
-        return (base ? base + '\n\n' : '') + block.join('\n') + '\n';
-    }
-    // Block ends at the next table header (any `[...]`) or EOF.
-    let end = lines.length;
-    for (let i = start + 1; i < lines.length; i++) {
-        if (/^\s*\[/.test(lines[i])) {
-            end = i;
-            break;
-        }
-    }
-    const before = lines.slice(0, start);
-    const after = lines.slice(end);
-    const sep = after.length && after[0].trim() !== '' ? [''] : []; // keep a blank line before a following table
-    return [...before, ...block, ...sep, ...after].join('\n').replace(/\n*$/, '\n');
-}
-/**
- * Read the connection state of a server from `claude mcp list` output. `connected`/`failed` when
- * a health marker (✓/✗) is shown, `registered` when listed without one, `absent` when not found.
- * (The verify step; the spawn that produces `output` is the live B-layer piece.)
- */
-export function parseClaudeMcpList(output, name = 'framein') {
-    for (const raw of output.split('\n')) {
-        const line = raw.trim();
-        const colon = line.indexOf(':');
-        if (colon === -1)
-            continue;
-        if (line.slice(0, colon).trim() !== name)
-            continue;
-        if (/✗|✘|fail/i.test(line))
-            return 'failed';
-        if (/✓|✔|connected/i.test(line))
-            return 'connected';
-        return 'registered';
-    }
-    return 'absent';
-}
+// Apply step of the MCP registration flow (§6.3: detect -> propose -> APPLY approved -> verify).
+// Pure, idempotent config-merge writers that ADD framein's own MCP server into each CLI's config
+// without clobbering anything else (same safety contract as managedBlock, ADR-0007 B-1). The
+// actual file write + live `claude mcp list` spawn live in cli.ts; only the parser below is pure.
+// Zero-dep: JSON via JSON.parse/stringify, TOML via a line-based text merge (no TOML serializer).
+/** framein registers itself as a subprocess MCP server each CLI launches (ADR-0007). */
+export const FRAMEIN_ENTRY = { command: 'framein', args: ['mcp', 'serve'] };
+/**
+ * Pick the spawn command the agent CLIs should use to launch framein's MCP server: the canonical
+ * `framein` bin when it's on PATH (installed product), else `node <abs cli.js>` (dev / not globally
+ * installed). The agent spawns this verbatim, so it MUST resolve to a real executable.
+ */
+export function resolveFrameinEntry(frameOnPath, cliPath) {
+    return frameOnPath ? { command: 'framein', args: ['mcp', 'serve'] } : { command: 'node', args: [cliPath, 'mcp', 'serve'] };
+}
+/**
+ * Merge `mcpServers.<name>` into a JSON config (Claude `.mcp.json`, Gemini `settings.json`),
+ * preserving every other key and server. Idempotent. Reformats with 2-space indent.
+ */
+export function applyJsonMcp(existing, name = 'framein', entry = FRAMEIN_ENTRY) {
+    let root = {};
+    if (existing && existing.trim()) {
+        const parsed = JSON.parse(existing);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+            root = parsed;
+    }
+    const prev = root.mcpServers;
+    const servers = prev && typeof prev === 'object' && !Array.isArray(prev) ? prev : {};
+    servers[name] = { command: entry.command, args: entry.args };
+    root.mcpServers = servers;
+    return JSON.stringify(root, null, 2) + '\n';
+}
+/**
+ * Merge a `[mcp_servers.<name>]` table into a Codex `config.toml` as text: replace the existing
+ * block (header line through the next table header / EOF) if present, else append. Idempotent.
+ * Preserves all other content; only the framein table is rewritten.
+ */
+export function applyCodexMcp(existing, name = 'framein', entry = FRAMEIN_ENTRY) {
+    const header = `[mcp_servers.${name}]`;
+    const block = [
+        header,
+        `command = ${JSON.stringify(entry.command)}`,
+        `args = [${entry.args.map((a) => JSON.stringify(a)).join(', ')}]`,
+    ];
+    const text = existing ?? '';
+    const lines = text.split('\n');
+    const start = lines.findIndex((l) => l.trim() === header);
+    if (start === -1) {
+        const base = text.trim();
+        return (base ? base + '\n\n' : '') + block.join('\n') + '\n';
+    }
+    // Block ends at the next table header (any `[...]`) or EOF.
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i++) {
+        if (/^\s*\[/.test(lines[i])) {
+            end = i;
+            break;
+        }
+    }
+    const before = lines.slice(0, start);
+    const after = lines.slice(end);
+    const sep = after.length && after[0].trim() !== '' ? [''] : []; // keep a blank line before a following table
+    return [...before, ...block, ...sep, ...after].join('\n').replace(/\n*$/, '\n');
+}
+/**
+ * Read the connection state of a server from `claude mcp list` output. `connected`/`failed` when
+ * a health marker (✓/✗) is shown, `registered` when listed without one, `absent` when not found.
+ * (The verify step; the spawn that produces `output` is the live B-layer piece.)
+ */
+export function parseClaudeMcpList(output, name = 'framein') {
+    for (const raw of output.split('\n')) {
+        const line = raw.trim();
+        const colon = line.indexOf(':');
+        if (colon === -1)
+            continue;
+        if (line.slice(0, colon).trim() !== name)
+            continue;
+        if (/✗|✘|fail/i.test(line))
+            return 'failed';
+        if (/✓|✔|connected/i.test(line))
+            return 'connected';
+        return 'registered';
+    }
+    return 'absent';
+}