@hegemonart/get-design-done 1.55.0 → 1.57.0

package/sdk/dashboard/data/source.cjs

@@ -58,6 +58,10 @@ function tryRequire(relPath) {
 const designContextQuery = tryRequire('scripts/lib/design-context-query.cjs');
 const eventChain = tryRequire('scripts/lib/event-chain.cjs');
 const healthMirror = tryRequire('scripts/lib/health-mirror/index.cjs');
+// Phase 57 (Round 3-E): state-store provides backendName() so the dashboard
+// model can surface whether it read from SQLite or markdown. Soft-loaded so
+// a missing module degrades without crashing. Never throws.
+const stateStore = tryRequire('scripts/lib/state/state-store.cjs');
 
 // ---------------------------------------------------------------------------
 // .ts shared libs — dynamic import(pathToFileURL), memoized.
@@ -211,23 +215,54 @@ function scrapeEventsFile(eventsPath) {
 
 /**
  * Load STATE.md-derived fields: status, phase(stage), cycle, decisions[],
- * blockers[]. Tries the typed sdk/state read() first, then the file scrape.
+ * blockers[], backend. Tries the typed sdk/state read() first (which is
+ * already migration-active-aware for Phase 57: when BACKEND==='sqlite' and
+ * a sibling state.sqlite exists, the dual-write path ensures STATE.md is
+ * byte-equal with SQLite so read() returns the canonical view), then the
+ * file-scrape fallback. Never throws.
+ *
+ * The `backend` field reflects the active state-store backend:
+ *   'sqlite'   — better-sqlite3 + FTS5 available and migration active
+ *   'markdown' — markdown floor (the universal default and CI surface)
  *
  * @param {string} root
  * @param {string[]} degraded
  * @returns {Promise<{status:string|null, phase:string|null, cycle:string|null,
- *           decisions:Array, blockers:Array}>}
+ *           decisions:Array, blockers:Array, backend:'sqlite'|'markdown'}>}
  */
 async function loadState(root, degraded) {
   const statePath = path.join(root, '.design', 'STATE.md');
-  const empty = { status: null, phase: null, cycle: null, decisions: [], blockers: [] };
+  const empty = {
+    status: null, phase: null, cycle: null,
+    decisions: [], blockers: [],
+    backend: /** @type {'sqlite'|'markdown'} */ ('markdown'),
+  };
+
+  // Determine the active backend for this specific state path (Phase 57 R3-E).
+  // The migration-active gate is:
+  //   BACKEND==='sqlite' AND existsSync(<statePath-sibling>/state.sqlite)
+  //
+  // We use state-store.backendName() to check the global probe result, then
+  // confirm by checking whether a sibling state.sqlite exists next to STATE.md.
+  // This mirrors the migrationActive() logic in sdk/state/index.ts exactly.
+  const globalBackend =
+    (stateStore && typeof stateStore.backendName === 'function')
+      ? /** @type {'sqlite'|'markdown'} */ (stateStore.backendName())
+      : 'markdown';
+  const sqliteSibling = path.join(root, '.design', 'state.sqlite');
+  const activeBackend = /** @type {'sqlite'|'markdown'} */ (
+    globalBackend === 'sqlite' && fs.existsSync(sqliteSibling) ? 'sqlite' : 'markdown'
+  );
 
   if (!fs.existsSync(statePath)) {
     degraded.push('state: .design/STATE.md not found');
-    return empty;
+    return { ...empty, backend: activeBackend };
   }
 
   // 1) Typed lib read() — the in-process shared surface (R1).
+  // Phase 57: sdk/state read() is already migration-active-aware; when
+  // BACKEND==='sqlite' and state.sqlite sibling exists, STATE.md is kept
+  // byte-equal by the dual-write path, so no separate SQLite read needed.
   try {
     const stateMod = await importState();
     if (stateMod && typeof stateMod.read === 'function') {
@@ -239,6 +274,7 @@ async function loadState(root, degraded) {
         cycle: (parsed.frontmatter && parsed.frontmatter.cycle) || null,
         decisions: Array.isArray(parsed.decisions) ? parsed.decisions : [],
         blockers: Array.isArray(parsed.blockers) ? parsed.blockers : [],
+        backend: activeBackend,
       };
     }
     degraded.push('state: sdk/state import unavailable — using file scrape');
@@ -246,7 +282,7 @@ async function loadState(root, degraded) {
     degraded.push(`state: typed read failed (${errMsg(err)}) — using file scrape`);
   }
 
-  // 2) File-scrape fallback.
+  // 2) File-scrape fallback (ultimate fallback; never throws).
   const scraped = scrapeStateFile(statePath);
   if (scraped) {
     return {
@@ -255,6 +291,7 @@ async function loadState(root, degraded) {
       cycle: scraped.cycle,
       decisions: scraped.decisions,
       blockers: scraped.blockers,
+      backend: 'markdown',
     };
   }
   degraded.push('state: scrape fallback failed');
@@ -508,6 +545,7 @@ function errMsg(err) {
  *   sessions: Array,
  *   degraded: string[],
  *   root: string,
+ *   backend: 'sqlite'|'markdown',
  * }>}
  */
 async function loadDashboardModel(opts = {}) {
@@ -564,6 +602,7 @@ async function loadDashboardModel(opts = {}) {
     sessions,
     degraded,
     root,
+    backend: stateRes.backend,
   };
 }
 

package/sdk/mcp/gdd-state/server.js

@@ -36,7 +36,7 @@ __export(server_exports, {
 });
 module.exports = __toCommonJS(server_exports);
 var import_node_fs5 = require("node:fs");
-var import_node_path3 = require("node:path");
+var import_node_path4 = require("node:path");
 var import_server = require("@modelcontextprotocol/sdk/server/index.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_types8 = require("@modelcontextprotocol/sdk/types.js");
@@ -196,6 +196,7 @@ __export(get_exports, {
 
 // sdk/state/index.ts
 var import_node_fs2 = require("node:fs");
+var import_node_path = require("node:path");
 
 // sdk/state/lockfile.ts
 var import_node_fs = require("node:fs");
@@ -349,7 +350,10 @@ function getErrnoCode(err) {
   return void 0;
 }
 function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+async function acquireSqliteLock(sqlitePath, opts = {}) {
+  return acquire(sqlitePath, opts);
 }
 
 // sdk/state/parser.ts
@@ -1727,11 +1731,64 @@ function gateFor(from, to) {
 }
 
 // sdk/state/index.ts
+function _findPackageRoot(startDir) {
+  let dir = (0, import_node_path.resolve)(startDir);
+  let firstWithPkg = null;
+  for (let i = 0; i < 12; i++) {
+    const pkgPath = (0, import_node_path.join)(dir, "package.json");
+    if ((0, import_node_fs2.existsSync)(pkgPath)) {
+      try {
+        const pkg = require(pkgPath);
+        if (firstWithPkg === null) firstWithPkg = dir;
+        if (pkg.name === "@hegemonart/get-design-done") return dir;
+      } catch {
+        if (firstWithPkg === null) firstWithPkg = dir;
+      }
+    }
+    const parent = (0, import_node_path.dirname)(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return firstWithPkg;
+}
+var _backendCache = null;
+function _loadBackend() {
+  if (_backendCache !== null) return _backendCache === false ? null : _backendCache;
+  try {
+    const pkgRoot = _findPackageRoot(__dirname);
+    if (pkgRoot === null) {
+      _backendCache = false;
+      return null;
+    }
+    const backendPath = (0, import_node_path.join)(pkgRoot, "scripts", "lib", "state", "state-backend.cjs");
+    if (!(0, import_node_fs2.existsSync)(backendPath)) {
+      _backendCache = false;
+      return null;
+    }
+    _backendCache = require(backendPath);
+    return _backendCache;
+  } catch {
+    _backendCache = false;
+    return null;
+  }
+}
+function migrationActive(statePath) {
+  const backend = _loadBackend();
+  if (backend === null || backend.BACKEND !== "sqlite") return false;
+  const sqliteSibling = (0, import_node_path.join)((0, import_node_path.dirname)(statePath), "state.sqlite");
+  return (0, import_node_fs2.existsSync)(sqliteSibling);
+}
 async function read(path2) {
   const raw = (0, import_node_fs2.readFileSync)(path2, "utf8");
   return parse(raw).state;
 }
 async function mutate(path2, fn) {
+  if (migrationActive(path2)) {
+    return _mutateSqliteActive(path2, fn);
+  }
+  return _mutateMarkdown(path2, fn);
+}
+async function _mutateMarkdown(path2, fn) {
   const release = await acquire(path2);
   const tmpPath = `${path2}.tmp`;
   try {
@@ -1768,6 +1825,46 @@ async function mutate(path2, fn) {
     await release();
   }
 }
+async function _mutateSqliteActive(path2, fn) {
+  const sqlitePath = (0, import_node_path.join)((0, import_node_path.dirname)(path2), "state.sqlite");
+  const releaseSqliteLock = await acquireSqliteLock(sqlitePath);
+  const release = await acquire(path2);
+  const tmpPath = `${path2}.tmp`;
+  try {
+    const raw = (0, import_node_fs2.readFileSync)(path2, "utf8");
+    const { state, raw_bodies, raw_frontmatter, block_gaps, line_ending } = parse(raw);
+    const clone = structuredClone(state);
+    const next = fn(clone);
+    const out = serialize(next, {
+      raw_frontmatter,
+      raw_bodies,
+      block_gaps,
+      line_ending
+    });
+    (0, import_node_fs2.writeFileSync)(tmpPath, out, "utf8");
+    try {
+      (0, import_node_fs2.renameSync)(tmpPath, path2);
+    } catch (err) {
+      const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
+      if (code === "EPERM" || code === "EBUSY") {
+        await new Promise((r) => setTimeout(r, 50));
+        (0, import_node_fs2.renameSync)(tmpPath, path2);
+      } else {
+        throw err;
+      }
+    }
+    return next;
+  } catch (err) {
+    try {
+      if ((0, import_node_fs2.existsSync)(tmpPath)) (0, import_node_fs2.unlinkSync)(tmpPath);
+    } catch {
+    }
+    throw err;
+  } finally {
+    await release();
+    await releaseSqliteLock();
+  }
+}
 async function transition(path2, toStage) {
   const beforeMutate = await read(path2);
   const from = beforeMutate.position.stage;
@@ -1798,7 +1895,7 @@ async function transition(path2, toStage) {
 }
 
 // sdk/mcp/gdd-state/tools/shared.ts
-var import_node_path2 = __toESM(require("node:path"));
+var import_node_path3 = __toESM(require("node:path"));
 var import_node_fs4 = require("node:fs");
 var import_node_module2 = require("node:module");
 
@@ -1848,13 +1945,13 @@ var EventBus = class extends import_node_events.EventEmitter {
 
 // sdk/event-stream/writer.ts
 var import_node_fs3 = require("node:fs");
-var import_node_path = require("node:path");
+var import_node_path2 = require("node:path");
 var import_node_module = require("node:module");
 function _findRepoRoot() {
   let dir = process.cwd();
   for (let i = 0; i < 8; i++) {
-    if ((0, import_node_fs3.existsSync)((0, import_node_path.join)(dir, "package.json"))) return dir;
-    const parent = (0, import_node_path.dirname)(dir);
+    if ((0, import_node_fs3.existsSync)((0, import_node_path2.join)(dir, "package.json"))) return dir;
+    const parent = (0, import_node_path2.dirname)(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -1863,16 +1960,16 @@ function _findRepoRoot() {
 var _redact;
 try {
   const _root = _findRepoRoot();
-  const _candidate = (0, import_node_path.resolve)(_root, "scripts/lib/redact.cjs");
+  const _candidate = (0, import_node_path2.resolve)(_root, "scripts/lib/redact.cjs");
   if ((0, import_node_fs3.existsSync)(_candidate)) {
-    const _redactRequire = (0, import_node_module.createRequire)((0, import_node_path.join)(_root, "package.json"));
+    const _redactRequire = (0, import_node_module.createRequire)((0, import_node_path2.join)(_root, "package.json"));
     const _mod = _redactRequire(_candidate);
     _redact = _mod.redact;
   } else {
-    const _altRoot = (0, import_node_path.resolve)(_root, "..", "..");
-    const _altCandidate = (0, import_node_path.resolve)(_altRoot, "scripts/lib/redact.cjs");
+    const _altRoot = (0, import_node_path2.resolve)(_root, "..", "..");
+    const _altCandidate = (0, import_node_path2.resolve)(_altRoot, "scripts/lib/redact.cjs");
     if ((0, import_node_fs3.existsSync)(_altCandidate)) {
-      const _altRequire = (0, import_node_module.createRequire)((0, import_node_path.join)(_altRoot, "package.json"));
+      const _altRequire = (0, import_node_module.createRequire)((0, import_node_path2.join)(_altRoot, "package.json"));
       const _altMod = _altRequire(_altCandidate);
       _redact = _altMod.redact;
     } else {
@@ -1898,7 +1995,7 @@ var EventWriter = class {
   directoryEnsured = false;
   constructor(opts = {}) {
     const rawPath = opts.path ?? DEFAULT_EVENTS_PATH;
-    this.path = (0, import_node_path.isAbsolute)(rawPath) ? rawPath : (0, import_node_path.resolve)(process.cwd(), rawPath);
+    this.path = (0, import_node_path2.isAbsolute)(rawPath) ? rawPath : (0, import_node_path2.resolve)(process.cwd(), rawPath);
     this.maxLineBytes = opts.maxLineBytes ?? DEFAULT_MAX_LINE_BYTES;
   }
   /**
@@ -1959,7 +2056,7 @@ var EventWriter = class {
    */
   ensureDirectory() {
     if (this.directoryEnsured) return;
-    (0, import_node_fs3.mkdirSync)((0, import_node_path.dirname)(this.path), { recursive: true });
+    (0, import_node_fs3.mkdirSync)((0, import_node_path2.dirname)(this.path), { recursive: true });
     this.directoryEnsured = true;
   }
 };
@@ -2017,8 +2114,8 @@ function getSessionId() {
 function _findRepoRoot2() {
   let dir = process.cwd();
   for (let i = 0; i < 8; i++) {
-    if ((0, import_node_fs4.existsSync)(import_node_path2.default.join(dir, "package.json"))) return dir;
-    const parent = import_node_path2.default.dirname(dir);
+    if ((0, import_node_fs4.existsSync)(import_node_path3.default.join(dir, "package.json"))) return dir;
+    const parent = import_node_path3.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -2027,9 +2124,9 @@ function _findRepoRoot2() {
 var _worktree = (() => {
   try {
     const root = _findRepoRoot2();
-    const candidate = import_node_path2.default.resolve(root, "scripts/lib/worktree-resolve.cjs");
+    const candidate = import_node_path3.default.resolve(root, "scripts/lib/worktree-resolve.cjs");
     if (!(0, import_node_fs4.existsSync)(candidate)) return null;
-    const req = (0, import_node_module2.createRequire)(import_node_path2.default.join(root, "package.json"));
+    const req = (0, import_node_module2.createRequire)(import_node_path3.default.join(root, "package.json"));
     return req(candidate);
   } catch {
     return null;
@@ -2042,20 +2139,20 @@ function resolveStatePath() {
       try {
         const designRoot = _worktree.resolveDesignRoot();
         if (_worktree.isWorktree()) {
-          _worktree.noticeOnce(import_node_path2.default.dirname(designRoot));
+          _worktree.noticeOnce(import_node_path3.default.dirname(designRoot));
         }
-        return import_node_path2.default.join(designRoot, "STATE.md");
+        return import_node_path3.default.join(designRoot, "STATE.md");
       } catch {
       }
     }
     return ".design/STATE.md";
   }
-  if (import_node_path2.default.isAbsolute(override)) {
-    return import_node_path2.default.resolve(override);
+  if (import_node_path3.default.isAbsolute(override)) {
+    return import_node_path3.default.resolve(override);
   }
-  const root = import_node_path2.default.resolve(process.cwd());
-  const resolved = import_node_path2.default.resolve(root, override);
-  const withSep = root.endsWith(import_node_path2.default.sep) ? root : root + import_node_path2.default.sep;
+  const root = import_node_path3.default.resolve(process.cwd());
+  const resolved = import_node_path3.default.resolve(root, override);
+  const withSep = root.endsWith(import_node_path3.default.sep) ? root : root + import_node_path3.default.sep;
   if (resolved !== root && !resolved.startsWith(withSep)) {
     throwValidation(
       "STATE_PATH_ESCAPE",
@@ -2763,16 +2860,16 @@ var TOOL_COUNT = TOOL_MODULES.length;
 var SERVER_NAME = "gdd-state";
 var SERVER_VERSION = "1.20.0";
 function here() {
-  const expectedRel = (0, import_node_path3.join)("sdk", "mcp", "gdd-state");
+  const expectedRel = (0, import_node_path4.join)("sdk", "mcp", "gdd-state");
   const entry = process.argv[1];
   if (typeof entry === "string" && entry.length > 0) {
-    const entryDir = (0, import_node_path3.dirname)((0, import_node_path3.resolve)(entry));
-    if ((0, import_node_fs5.existsSync)((0, import_node_path3.join)(entryDir, "tools", "index.ts"))) {
+    const entryDir = (0, import_node_path4.dirname)((0, import_node_path4.resolve)(entry));
+    if ((0, import_node_fs5.existsSync)((0, import_node_path4.join)(entryDir, "tools", "index.ts"))) {
       return entryDir;
     }
   }
-  const candidate = (0, import_node_path3.resolve)(process.cwd(), expectedRel);
-  if ((0, import_node_fs5.existsSync)((0, import_node_path3.join)(candidate, "tools", "index.ts"))) {
+  const candidate = (0, import_node_path4.resolve)(process.cwd(), expectedRel);
+  if ((0, import_node_fs5.existsSync)((0, import_node_path4.join)(candidate, "tools", "index.ts"))) {
     return candidate;
   }
   return candidate;
@@ -2780,7 +2877,7 @@ function here() {
 function loadTools() {
   const baseDir = here();
   return TOOL_MODULES.map((m) => {
-    const absPath = (0, import_node_path3.join)(baseDir, "tools", m.schemaPath);
+    const absPath = (0, import_node_path4.join)(baseDir, "tools", m.schemaPath);
     const raw = (0, import_node_fs5.readFileSync)(absPath, "utf8");
     const parsed = JSON.parse(raw);
     const rawInput = parsed.properties?.input;

package/sdk/mcp/gdd-state/tools/get.ts

@@ -5,6 +5,14 @@
 // event. Optionally projects a subset of fields when `input.fields` is
 // provided; unknown field names are silently ignored so callers can pass
 // a broad list without pre-flight knowledge of ParsedState shape.
+//
+// Phase 57 (Round 3-E): this tool already benefits from the SQLite read
+// path transparently. `sdk/state/index.ts` `read()` delegates through the
+// migration-active gate: when BACKEND==='sqlite' and a sibling state.sqlite
+// exists the dual-write path keeps STATE.md byte-equal with SQLite state,
+// so reading the on-disk STATE.md returns the canonical view regardless of
+// which backend is active. No behavioral change is required here and the
+// tool input/output SCHEMA IS UNCHANGED (no mcp-tools-manifest hash drift).
 
 import { read } from '../../../state/index.ts';
 import type { ParsedState } from '../../../state/types.ts';