monomind 2.7.9 → 2.7.11

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/live/manual-edit-routes.mjs

@@ -1,357 +0,0 @@
-import { validateEvent } from './event-validation.mjs';
-import {
-  countByPage as countPendingByPage,
-  readBuffer as readManualEditsBuffer,
-  removeEntries as removeManualEditEntries,
-  stageEntry as stageManualEditEntry,
-  truncateBuffer as truncateManualEditsBuffer,
-} from './manual-edits-buffer.mjs';
-import {
-  summarizeManualApplyFailures,
-  summarizeManualDiagnostics,
-  summarizeManualLogFile,
-} from './manual-apply.mjs';
-import { buildManualEditEvidence } from '../live-manual-edit-evidence.mjs';
-import { commitManualEdits } from '../live-commit-manual-edits.mjs';
-
-export function createManualEditRoutes({
-  getToken,
-  manualApply,
-  recordManualEditActivity,
-  getManualEditStatus,
-  chatAgentLikelyActive,
-  cwd = () => process.cwd(),
-  env = () => process.env,
-} = {}) {
-  const projectCwd = () => typeof cwd === 'function' ? cwd() : cwd || process.cwd();
-  const currentEnv = () => typeof env === 'function' ? env() : env || process.env;
-
-  return function handleManualEditRoute(req, res, url) {
-    const p = url.pathname;
-
-    // Save stages entries; Apply commits the staged page batch through the
-    // local AI copy-edit runner.
-    if (p === '/manual-edit-stash' && req.method === 'POST') {
-      let body = '';
-      req.on('data', (c) => { body += c; });
-      req.on('end', () => {
-        let msg;
-        try { msg = JSON.parse(body); } catch {
-          sendJson(res, 400, { error: 'Invalid JSON' });
-          return;
-        }
-        if (msg.token !== getToken()) {
-          sendJson(res, 401, { error: 'Unauthorized' });
-          return;
-        }
-        const error = validateEvent({ ...msg, type: 'manual_edits' });
-        if (error) {
-          sendJson(res, 400, { error });
-          return;
-        }
-        try {
-          stageManualEditEntry(projectCwd(), {
-            id: msg.id,
-            pageUrl: msg.pageUrl,
-            element: msg.element,
-            ops: msg.ops,
-          });
-        } catch (err) {
-          sendJson(res, 500, { error: 'stash_write_failed', message: err.message });
-          return;
-        }
-        const { totalCount, perPage } = countPendingByPage(projectCwd());
-        const pendingCount = perPage[msg.pageUrl] || 0;
-        recordManualEditActivity('manual_edit_stashed', {
-          id: msg.id,
-          pageUrl: msg.pageUrl,
-          opCount: msg.ops.length,
-          pendingCount,
-          totalCount,
-          hintedFileCount: new Set((msg.ops || []).map((op) => summarizeManualLogFile(op.sourceHint?.file, projectCwd())).filter(Boolean)).size,
-        });
-        sendJson(res, 200, { ok: true, pendingCount, totalCount, perPage });
-      });
-      return true;
-    }
-
-    if (p === '/manual-edit-stash' && req.method === 'GET') {
-      const token = url.searchParams.get('token');
-      if (token !== getToken()) { res.writeHead(401); res.end('Unauthorized'); return true; }
-      const pageUrl = url.searchParams.get('pageUrl') || '';
-      const { totalCount, perPage } = countPendingByPage(projectCwd());
-      const buffer = readManualEditsBuffer(projectCwd());
-      const entriesForPage = pageUrl ? buffer.entries.filter((e) => e.pageUrl === pageUrl) : buffer.entries;
-      sendJson(res, 200, {
-        count: pageUrl ? (perPage[pageUrl] || 0) : totalCount,
-        totalCount,
-        perPage,
-        entries: entriesForPage,
-      });
-      return true;
-    }
-
-    if (p === '/manual-edit-commit' && req.method === 'POST') {
-      const token = url.searchParams.get('token');
-      if (token !== getToken()) { res.writeHead(401); res.end('Unauthorized'); return true; }
-      const pageUrl = url.searchParams.get('pageUrl');
-      const asyncMode = /^(1|true|yes)$/i.test(url.searchParams.get('async') || '');
-      const repairOnly = /^(1|true|yes)$/i.test(url.searchParams.get('repair') || '');
-      const existingTransaction = manualApply.readTransaction();
-      if (repairOnly && !existingTransaction) {
-        sendJson(res, 409, { error: 'manual_edit_repair_transaction_missing' });
-        return true;
-      }
-      const recoveredTransaction = repairOnly ? null : manualApply.rollbackTransaction({
-        pageUrl,
-        reason: 'manual_edit_commit_recovered_abandoned_transaction',
-      });
-      const before = getManualEditStatus();
-      const pendingCount = pageUrl ? (before.perPage[pageUrl] || 0) : before.totalCount;
-      recordManualEditActivity('manual_edit_commit_started', {
-        pageUrl,
-        repairOnly,
-        pendingCount,
-        totalCount: before.totalCount,
-        recoveredTransaction: recoveredTransaction ? {
-          id: recoveredTransaction.id,
-          reason: recoveredTransaction.reason,
-          skipped: recoveredTransaction.skipped,
-          rolledBackFiles: recoveredTransaction.rolledBackFiles,
-          rollbackFailures: summarizeManualDiagnostics(recoveredTransaction.rollbackFailures, projectCwd()),
-        } : null,
-        ...summarizePendingManualEditBatch(projectCwd(), pageUrl),
-      });
-      if (asyncMode) {
-        sendJson(res, 202, {
-          status: 'started',
-          pendingCount,
-          totalCount: before.totalCount,
-          perPage: before.perPage,
-        });
-      }
-      (async () => {
-        let result;
-        let routedProvider = 'subprocess';
-        let transaction = null;
-        let commitBatch = null;
-        try {
-          if (pendingCount > 0) {
-            const transactionBatch = buildManualEditEvidence({ cwd: projectCwd(), pageUrl });
-            commitBatch = transactionBatch;
-            if (!repairOnly && manualApply.countOps(transactionBatch) > 0) {
-              transaction = manualApply.writeTransaction({
-                pageUrl,
-                batch: transactionBatch,
-              });
-            } else if (repairOnly && existingTransaction) {
-              transaction = existingTransaction;
-            }
-          }
-          const envValue = currentEnv();
-          const requestedMode = (envValue.MONODESIGN_LIVE_COPY_AGENT || 'auto').trim().toLowerCase();
-          const useChatRoute = requestedMode === 'chat'
-            || (requestedMode === 'auto' && chatAgentLikelyActive());
-          if (useChatRoute) {
-            routedProvider = 'chat';
-            const timeoutMs = Number(envValue.MONODESIGN_LIVE_COPY_AGENT_TIMEOUT_MS || 120000);
-            result = await commitManualEdits({
-              cwd: projectCwd(),
-              pageUrl,
-              provider: 'chat',
-              env: envValue,
-              timeoutMs,
-              chatAvailable: chatAgentLikelyActive,
-              applyBatchToSource: (batch, context) => manualApply.pushBatchInChunksAndWait(batch, pageUrl, context),
-              repairOnly,
-              transactionId: transaction?.id || existingTransaction?.id || null,
-              batch: commitBatch,
-            });
-          } else {
-            const timeoutMs = Number(envValue.MONODESIGN_LIVE_COPY_AGENT_TIMEOUT_MS || 120000);
-            const provider = ['codex', 'claude', 'mock'].includes(requestedMode) ? requestedMode : undefined;
-            result = await commitManualEdits({
-              cwd: projectCwd(),
-              pageUrl,
-              provider,
-              env: envValue,
-              timeoutMs,
-              chatAvailable: chatAgentLikelyActive,
-              repairOnly,
-              transactionId: transaction?.id || existingTransaction?.id || null,
-              batch: commitBatch,
-            });
-          }
-        } catch (err) {
-          if (transaction) {
-            manualApply.rollbackTransaction({
-              pageUrl,
-              reason: 'manual_edit_commit_exception',
-            });
-          }
-          const message = err.stderr?.toString?.() || err.message;
-          recordManualEditActivity('manual_edit_commit_failed', {
-            pageUrl,
-            provider: routedProvider,
-            error: 'manual_edit_commit_failed',
-            message,
-            transactionId: transaction?.id || null,
-          });
-          if (!asyncMode) {
-            sendJson(res, 500, {
-              error: 'manual_edit_commit_failed',
-              message,
-            });
-          }
-          return;
-        } finally {
-          if (transaction) {
-            const shouldKeepTransaction = result?.needsManualDecision === true;
-            if (!shouldKeepTransaction) manualApply.clearTransaction(transaction.id);
-          }
-        }
-        const { totalCount, perPage } = countPendingByPage(projectCwd());
-        if (result?.needsManualDecision) {
-          recordManualEditActivity('manual_edit_repair_needs_decision', {
-            pageUrl,
-            provider: routedProvider,
-            transactionId: transaction?.id || existingTransaction?.id || null,
-            repair: result.repair || null,
-            failed: summarizeManualApplyFailures(result.failed, projectCwd()),
-            files: Array.isArray(result.files) ? result.files.slice(0, 20).map((file) => summarizeManualLogFile(file, projectCwd())).filter(Boolean) : [],
-            remainingCount: pageUrl ? (perPage[pageUrl] || 0) : totalCount,
-            totalCount,
-          });
-        } else {
-          recordManualEditActivity('manual_edit_commit_done', {
-            pageUrl,
-            provider: routedProvider,
-            reason: result.reason || null,
-            repair: result.repair || null,
-            appliedCount: Array.isArray(result.applied) ? result.applied.length : 0,
-            failedCount: Array.isArray(result.failed) ? result.failed.length : 0,
-            failed: summarizeManualApplyFailures(result.failed, projectCwd()),
-            files: Array.isArray(result.files) ? result.files.slice(0, 20).map((file) => summarizeManualLogFile(file, projectCwd())).filter(Boolean) : [],
-            warnings: summarizeManualDiagnostics(result.warnings, projectCwd()),
-            rolledBackFiles: Array.isArray(result.rolledBackFiles) ? result.rolledBackFiles.slice(0, 20).map((file) => summarizeManualLogFile(file, projectCwd())).filter(Boolean) : [],
-            rollbackFailures: summarizeManualDiagnostics(result.rollbackFailures, projectCwd()),
-            unreportedFiles: Array.isArray(result.unreportedFiles) ? result.unreportedFiles.slice(0, 20).map((file) => summarizeManualLogFile(file, projectCwd())).filter(Boolean) : undefined,
-            noteCount: Array.isArray(result.notes) ? result.notes.length : 0,
-            cleared: result.cleared || 0,
-            remainingCount: pageUrl ? (perPage[pageUrl] || 0) : totalCount,
-            totalCount,
-          });
-        }
-        if (!asyncMode) {
-          sendJson(res, 200, { ...result, totalCount, perPage });
-        }
-      })();
-      return true;
-    }
-
-    if (p === '/manual-edit-repair-decision' && req.method === 'POST') {
-      let body = '';
-      req.on('data', (chunk) => { body += chunk; });
-      req.on('end', () => {
-        let payload = {};
-        try { payload = body ? JSON.parse(body) : {}; } catch {
-          sendJson(res, 400, { error: 'Invalid JSON' });
-          return;
-        }
-        const token = payload.token || url.searchParams.get('token');
-        if (token !== getToken()) { res.writeHead(401); res.end('Unauthorized'); return; }
-        const pageUrl = payload.pageUrl || url.searchParams.get('pageUrl') || null;
-        const action = String(payload.action || url.searchParams.get('action') || '').trim().toLowerCase();
-        if (action !== 'rollback') {
-          sendJson(res, 400, { error: 'unsupported_manual_edit_repair_decision', action });
-          return;
-        }
-        const rollback = manualApply.rollbackTransaction({
-          pageUrl,
-          reason: 'manual_edit_user_requested_rollback',
-        });
-        const { totalCount, perPage } = countPendingByPage(projectCwd());
-        const response = {
-          action,
-          pageUrl,
-          rollback,
-          remainingCount: pageUrl ? (perPage[pageUrl] || 0) : totalCount,
-          totalCount,
-          perPage,
-        };
-        recordManualEditActivity('manual_edit_repair_rollback_done', response);
-        sendJson(res, 200, response);
-      });
-      return true;
-    }
-
-    if (p === '/manual-edit-discard' && req.method === 'POST') {
-      const token = url.searchParams.get('token');
-      if (token !== getToken()) { res.writeHead(401); res.end('Unauthorized'); return true; }
-      const pageUrl = url.searchParams.get('pageUrl');
-      let discarded;
-      let discardedEntries = [];
-      let canceledApplyEvents = [];
-      let transactionRollback = null;
-      try {
-        const buffer = readManualEditsBuffer(projectCwd());
-        transactionRollback = manualApply.rollbackTransaction({
-          pageUrl,
-          reason: 'manual_edit_discarded',
-        });
-        if (pageUrl) {
-          discardedEntries = buffer.entries.filter((entry) => entry.pageUrl === pageUrl);
-          discarded = removeManualEditEntries(projectCwd(), (entry) => entry.pageUrl === pageUrl);
-        } else {
-          discardedEntries = buffer.entries;
-          discarded = truncateManualEditsBuffer(projectCwd());
-        }
-        canceledApplyEvents = manualApply.cancelPendingEvents(pageUrl);
-      } catch (err) {
-        sendJson(res, 500, { error: 'discard_failed', message: err.message });
-        return true;
-      }
-      const { totalCount, perPage } = countPendingByPage(projectCwd());
-      recordManualEditActivity('manual_edit_discarded', {
-        pageUrl,
-        discarded,
-        canceledApplyIds: canceledApplyEvents.map((event) => event.id),
-        transactionRollback: transactionRollback ? {
-          id: transactionRollback.id,
-          rolledBackFiles: transactionRollback.rolledBackFiles?.map((file) => summarizeManualLogFile(file, projectCwd())).filter(Boolean) || [],
-          rollbackFailures: summarizeManualDiagnostics(transactionRollback.rollbackFailures, projectCwd()),
-          skipped: transactionRollback.skipped,
-        } : undefined,
-        totalCount,
-      });
-      sendJson(res, 200, { discarded, entries: discardedEntries, canceledApplyEvents, totalCount, perPage });
-      return true;
-    }
-
-    if (p === '/manual-edit' && req.method === 'POST') {
-      sendJson(res, 410, { error: '/manual-edit is removed; use /manual-edit-stash and /manual-edit-commit for staged copy edits.' });
-      return true;
-    }
-
-    return false;
-  };
-}
-
-function sendJson(res, status, body) {
-  res.writeHead(status, { 'Content-Type': 'application/json' });
-  res.end(JSON.stringify(body));
-}
-
-function summarizePendingManualEditBatch(cwd, pageUrl = null) {
-  try {
-    const buffer = readManualEditsBuffer(cwd);
-    const entries = (buffer.entries || [])
-      .filter((entry) => !pageUrl || entry.pageUrl === pageUrl);
-    return {
-      pendingEntryCount: entries.length,
-      pendingOpCount: entries.reduce((sum, entry) => sum + (entry.ops?.length || 0), 0),
-    };
-  } catch (err) {
-    return { pendingSummaryError: err.message || String(err) };
-  }
-}

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/live/manual-edits-buffer.mjs

@@ -1,152 +0,0 @@
-/**
- * Shared helpers for the pending-manual-edits buffer on disk.
- *
- * Location: .monodesign/live/pending-manual-edits.json (project-local).
- * Schema:   { version: 1, entries: [{ id, pageUrl, element, ops, stagedAt }] }
- *
- * Each entry corresponds to one Save action from the browser. Ops merge by
- * (pageUrl, ref): if the user re-edits the same element before committing, the
- * existing entry's `newText` is replaced and `originalText` is kept (it holds
- * the real source state).
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { getLiveDir } from '../lib/monodesign-paths.mjs';
-
-const BUFFER_VERSION = 1;
-const BUFFER_FILENAME = 'pending-manual-edits.json';
-
-export function getBufferPath(cwd = process.cwd()) {
-  return path.join(getLiveDir(cwd), BUFFER_FILENAME);
-}
-
-export function readBuffer(cwd = process.cwd()) {
-  return readBufferInternal(cwd, { strict: false });
-}
-
-export function readBufferStrict(cwd = process.cwd()) {
-  return readBufferInternal(cwd, { strict: true });
-}
-
-function readBufferInternal(cwd, { strict }) {
-  const filePath = getBufferPath(cwd);
-  try {
-    const raw = fs.readFileSync(filePath, 'utf-8');
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.entries)) {
-      if (strict) throw new Error('manual_edit_buffer_invalid_schema');
-      return { version: BUFFER_VERSION, entries: [] };
-    }
-    return { version: BUFFER_VERSION, entries: parsed.entries };
-  } catch (err) {
-    if (strict && err?.code !== 'ENOENT') {
-      throw new Error('manual_edit_buffer_unreadable: ' + (err.message || String(err)));
-    }
-    return { version: BUFFER_VERSION, entries: [] };
-  }
-}
-
-export function writeBuffer(cwd, buffer) {
-  const filePath = getBufferPath(cwd);
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, JSON.stringify({ version: BUFFER_VERSION, entries: buffer.entries }, null, 2));
-}
-
-/**
- * Merge a new entry into the buffer. For each op in the new entry, if there's
- * already a buffered op for the same (pageUrl, ref), update that op's newText
- * and keep its original originalText (the true source state). Otherwise add
- * the op (creating an entry if needed).
- *
- * Multiple ops in one Save are allowed; each is keyed by (pageUrl, ref).
- */
-export function stageEntry(cwd, newEntry) {
-  const buf = readBufferStrict(cwd);
-  const pageUrl = newEntry.pageUrl;
-  for (const newOp of newEntry.ops) {
-    let mergedIntoExisting = false;
-    for (const existing of buf.entries) {
-      if (existing.pageUrl !== pageUrl) continue;
-      const existingOpIdx = existing.ops.findIndex((op) => op.ref === newOp.ref);
-      if (existingOpIdx >= 0) {
-        // Keep the original source text but refresh the latest DOM/source evidence.
-        existing.ops[existingOpIdx] = {
-          ...newOp,
-          originalText: existing.ops[existingOpIdx].originalText,
-          newText: newOp.newText,
-          deleted: newOp.deleted || false,
-        };
-        if (newEntry.element) existing.element = newEntry.element;
-        existing.stagedAt = new Date().toISOString();
-        mergedIntoExisting = true;
-        break;
-      }
-    }
-    if (mergedIntoExisting) continue;
-    // No existing op for this (pageUrl, ref). Find or create an entry to hold it.
-    let entry = buf.entries.find((e) => e.pageUrl === pageUrl && e.id === newEntry.id);
-    if (!entry) {
-      entry = {
-        id: newEntry.id,
-        pageUrl,
-        element: newEntry.element,
-        ops: [],
-        stagedAt: new Date().toISOString(),
-      };
-      buf.entries.push(entry);
-    }
-    entry.ops.push(newOp);
-    entry.stagedAt = new Date().toISOString();
-  }
-  writeBuffer(cwd, buf);
-  return buf;
-}
-
-/**
- * Remove entries matching a predicate. Returns count of removed *ops* (not
- * entries) so callers report a unit consistent with truncateBuffer and the
- * pill's per-page op count. Empty entries (no ops left) are also pruned.
- */
-export function removeEntries(cwd, predicate) {
-  const buf = readBuffer(cwd);
-  let removedOps = 0;
-  const kept = [];
-  for (const entry of buf.entries) {
-    if (predicate(entry)) {
-      removedOps += entry.ops?.length || 0;
-    } else if (entry.ops && entry.ops.length > 0) {
-      kept.push(entry);
-    }
-  }
-  buf.entries = kept;
-  writeBuffer(cwd, buf);
-  return removedOps;
-}
-
-/**
- * Count by page for the counter UI. Returns { totalCount, perPage: {[pageUrl]: count} }.
- */
-export function countByPage(cwd = process.cwd()) {
-  const buf = readBuffer(cwd);
-  const perPage = {};
-  let totalCount = 0;
-  for (const entry of buf.entries) {
-    const n = entry.ops.length;
-    perPage[entry.pageUrl] = (perPage[entry.pageUrl] || 0) + n;
-    totalCount += n;
-  }
-  return { totalCount, perPage };
-}
-
-/**
- * Truncate the buffer to empty (used by discard-all). Returns the count of
- * removed ops.
- */
-export function truncateBuffer(cwd) {
-  const buf = readBuffer(cwd);
-  let removed = 0;
-  for (const entry of buf.entries) removed += entry.ops.length;
-  writeBuffer(cwd, { version: BUFFER_VERSION, entries: [] });
-  return removed;
-}