@smartmemory/compose 0.2.49-beta → 0.2.51-beta

package/server/build-routes.js

@@ -13,15 +13,36 @@
  * tests; it lets a caller inject mock `runBuild` / `abortBuild` / `getDataDir`.
  */
 
+import fs from 'node:fs';
+import path from 'node:path';
 import { runBuild as defaultRunBuild, abortBuild as defaultAbortBuild } from '../lib/build.js';
+import { runNew as defaultRunNew } from '../lib/new.js';
+import { runBuildAll as defaultRunBuildAll } from '../lib/build-all.js';
+import { runGsd as defaultRunGsd } from '../lib/gsd.js';
 import { requireSensitiveOrPaired as requireSensitiveToken } from './security.js';
-import { getDataDir as defaultGetDataDir } from './project-root.js';
+import { getDataDir as defaultGetDataDir, getTargetRoot as defaultGetTargetRoot } from './project-root.js';
 import { readBuildHistory } from '../lib/build-history.js';
 
+// A launcher conflict (another build/GSD run already owns the feature) is a
+// user-facing 409, not a 500. runBuild surfaces "already active"; runGsd
+// refuses a concurrent run ("Refusing to start a concurrent run").
+function launcherErrorStatus(err) {
+  const msg = err && err.message ? err.message : '';
+  return /already active|already running|concurrent run|refusing to start/i.test(msg) ? 409 : 500;
+}
+
 export function attachBuildRoutes(app, deps = {}) {
   const runBuild = deps.runBuild || defaultRunBuild;
   const abortBuild = deps.abortBuild || defaultAbortBuild;
+  const runNew = deps.runNew || defaultRunNew;
+  const runBuildAll = deps.runBuildAll || defaultRunBuildAll;
+  const runGsd = deps.runGsd || defaultRunGsd;
   const getDataDir = deps.getDataDir || defaultGetDataDir;
+  // Bind build dispatch to the active project root (the same global target the
+  // vision store + getDataDir() use). Without this the runners default to
+  // process.cwd(), which switchProject() does not chdir — so after a project
+  // switch the cockpit and a launched build could target different workspaces.
+  const getTargetRoot = deps.getTargetRoot || defaultGetTargetRoot;
 
   // COMP-COCKPIT-3: read-only past-builds history. No sensitive token —
   // mirrors GET /api/build/state (read-only, no secrets in the records).
@@ -38,22 +59,81 @@ export function attachBuildRoutes(app, deps = {}) {
 
   app.post('/api/build/start', requireSensitiveToken, async (req, res) => {
     const body = req.body || {};
-    const { featureCode, mode = 'feature', description = '' } = body;
-    if (!featureCode) {
+    const { featureCode, mode = 'feature', description = '', resume = false } = body;
+
+    // featureCode is required for feature/bug/gsd; 'new' takes a free-text
+    // intent (no code yet) and 'all' sweeps every PLANNED feature.
+    if (!featureCode && mode !== 'all' && mode !== 'new') {
       return res.status(400).json({ error: 'featureCode required' });
     }
-    if (mode !== 'feature' && mode !== 'bug') {
-      return res.status(400).json({ error: "mode must be 'feature' or 'bug'" });
+    if (!['feature', 'bug', 'new', 'all', 'gsd'].includes(mode)) {
+      return res.status(400).json({ error: "mode must be 'feature', 'bug', 'new', 'all', or 'gsd'" });
     }
+
+    // PARITY-2: launch the `new` lifecycle from a description (intent).
+    if (mode === 'new') {
+      const intent = (description || '').trim();
+      if (!intent) {
+        return res.status(400).json({ error: 'intent (description) required for mode=new' });
+      }
+      try {
+        const result = await runNew(intent, { cwd: getTargetRoot() });
+        return res.json(result ?? { ok: true });
+      } catch (err) {
+        return res.status(500).json({ error: err.message || String(err) });
+      }
+    }
+
+    // PARITY-8: build-all sweep.
+    if (mode === 'all') {
+      try {
+        const result = await runBuildAll({ cwd: getTargetRoot() });
+        return res.json(result ?? { ok: true });
+      } catch (err) {
+        return res.status(launcherErrorStatus(err)).json({ error: err.message || String(err) });
+      }
+    }
+
+    // PARITY-8: GSD autonomous run for a single feature.
+    if (mode === 'gsd') {
+      try {
+        const result = await runGsd(featureCode, { cwd: getTargetRoot() });
+        return res.json(result ?? { ok: true });
+      } catch (err) {
+        return res.status(launcherErrorStatus(err)).json({ error: err.message || String(err) });
+      }
+    }
+
+    // PARITY-2: resume an interrupted bug-fix flow from active-build.json.
+    let resumeFlowId = null;
+    if (resume === true) {
+      if (mode !== 'bug') {
+        return res.status(400).json({ error: 'resume is only supported for mode=bug' });
+      }
+      let active = null;
+      try {
+        const activePath = path.join(getDataDir(), 'active-build.json');
+        active = JSON.parse(fs.readFileSync(activePath, 'utf8'));
+      } catch {
+        active = null;
+      }
+      if (!active || active.featureCode !== featureCode || !active.flowId) {
+        return res.status(409).json({ error: 'no resumable build for featureCode' });
+      }
+      if (active.mode && active.mode !== 'bug') {
+        return res.status(409).json({ error: `active build is mode=${active.mode}, not resumable as bug` });
+      }
+      resumeFlowId = active.flowId;
+    }
+
     try {
       const opts = mode === 'bug'
-        ? { mode, template: 'bug-fix', description }
-        : { mode, description };
+        ? { mode, template: 'bug-fix', description, cwd: getTargetRoot(), ...(resumeFlowId ? { resumeFlowId } : {}) }
+        : { mode, description, cwd: getTargetRoot() };
       const result = await runBuild(featureCode, opts);
       res.json(result ?? { ok: true });
     } catch (err) {
-      const code = /already active/i.test(err && err.message ? err.message : '') ? 409 : 500;
-      res.status(code).json({ error: err.message || String(err) });
+      res.status(launcherErrorStatus(err)).json({ error: err.message || String(err) });
     }
   });
 

package/server/build-stream-bridge.js

@@ -471,6 +471,18 @@ export class BuildStreamBridge {
         };
       }
 
+      // COMP-TEST-BOOTSTRAP-4-1: advisory review of the tests the coverage step
+      // generated this build. Forwarded so the cockpit can surface the findings
+      // for human verification (the step never blocks ship).
+      case 'test_review':
+        return {
+          type: 'system', subtype: 'test_review',
+          clean: event.clean ?? true,
+          summary: event.summary ?? '',
+          findings: event.findings ?? [],
+          _source: 'build',
+        };
+
       // COMP-HEALTH item 118: health score after build completion
       case 'health_score':
         return {

package/server/compose-mcp-tools.js

@@ -359,10 +359,82 @@ export async function toolProposeFollowup(args) {
   // propose_followup also accepts a caller-supplied `status` and routes to
   // addRoadmapEntry — gate lifecycle-owned terminal statuses the same way.
   assertTerminalStatusAuthorized(args, 'propose_followup');
-  const { proposeFollowup } = await import('../lib/followup-writer.js');
+  let proposeFollowup;
+  try {
+    ({ proposeFollowup } = await import('../lib/followup-writer.js'));
+  } catch (err) {
+    // COMP-MCP-FOLLOWUP-1: a long-running stdio MCP server caches ESM module
+    // records. If lib/ changed under it (e.g. a later commit added an export
+    // this lazily-imported module now depends on), linking fails with a cryptic
+    // "does not provide an export named ..." even though the on-disk code is
+    // correct — the running server just needs to reload. Rethrow with an
+    // actionable hint instead of the raw ESM error.
+    if (/does not provide an export named|Cannot find module/i.test(err?.message || '')) {
+      const hint = new Error(
+        `propose_followup could not load lib/followup-writer.js: ${err.message}. ` +
+        `This usually means the compose MCP server is running stale code (module-cache skew after a ` +
+        `code change) — reconnect the MCP server (/mcp) to reload it. If it persists after reconnecting, ` +
+        `an export is genuinely missing on disk.`,
+      );
+      hint.cause = err;
+      throw hint;
+    }
+    throw err;
+  }
   return proposeFollowup(getTargetRoot(), args);
 }
 
+// ---------------------------------------------------------------------------
+// Eager boot-time module preload — COMP-MCP-FOLLOWUP-1-1
+// ---------------------------------------------------------------------------
+
+/**
+ * Modules reachable only via a lazy `import()` on a hot tool path, which
+ * therefore escape boot-time ESM linking. Eager-importing them at server start
+ * makes a genuine on-disk break (missing module OR missing export) fail fast at
+ * boot instead of surfacing on first tool invocation — complementing the
+ * COMP-MCP-FOLLOWUP-1 CI import-graph test.
+ *
+ * The default set is exactly one module: `lib/followup-writer.js`, lazily
+ * imported by `toolProposeFollowup`. Its own dynamic import
+ * (`server/artifact-manager.js`) is already statically imported at the top of
+ * this file, so it links at boot regardless — no need to list it here.
+ */
+export const EAGER_PRELOAD_MODULES = [
+  { specifier: '../lib/followup-writer.js', expect: 'proposeFollowup' },
+];
+
+/**
+ * Eagerly import each spec and assert its expected export is a function.
+ * Throws (naming the offending module) on a missing module or missing export.
+ *
+ * `await import()` does NOT throw when a module loads but no longer provides the
+ * expected named export — it resolves with that binding `undefined`. So the
+ * binding check, not the import alone, is what turns a missing export into a
+ * boot failure (the exact COMP-MCP-FOLLOWUP-1 failure class).
+ *
+ * `specs` is injectable for testing and for the `COMPOSE_PRELOAD_PROBE` boot
+ * seam; entries without an `expect` are import-only checks.
+ */
+export async function preloadEagerModules(specs = EAGER_PRELOAD_MODULES) {
+  const loaded = {};
+  for (const { specifier, expect } of specs) {
+    let mod;
+    try {
+      mod = await import(specifier);
+    } catch (err) {
+      throw new Error(`eager preload failed for ${specifier}: ${err.message}`, { cause: err });
+    }
+    if (expect && typeof mod[expect] !== 'function') {
+      throw new Error(
+        `eager preload failed for ${specifier}: expected export '${expect}' to be a function, got ${typeof mod[expect]}`,
+      );
+    }
+    loaded[specifier] = mod;
+  }
+  return loaded;
+}
+
 // ---------------------------------------------------------------------------
 // Checkpoints / resume — COMP-RESUME
 // ---------------------------------------------------------------------------

package/server/compose-mcp.js

@@ -26,6 +26,7 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { writeSync } from 'node:fs';
 import {
   toolGetVisionItems,
   toolGetRoadmap,
@@ -71,6 +72,8 @@ import {
   assertToolPhaseAllowed,
   _getSessionProfile,
   resolveBoundPhase,
+  preloadEagerModules,
+  EAGER_PRELOAD_MODULES,
 } from './compose-mcp-tools.js';
 import { isToolAllowed } from './mcp-tool-policy.js';
 import { switchProject, getTargetRoot, loadProjectConfig } from './project-root.js';
@@ -817,6 +820,30 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 // Start
 // ---------------------------------------------------------------------------
 
+// COMP-MCP-FOLLOWUP-1-1: eager-preload lazily-imported hot-path modules so a
+// genuine on-disk break (missing module/export) fails fast at boot instead of
+// on first tool call. COMPOSE_PRELOAD_PROBE is an ops/test seam: comma-separated
+// entries appended to the default set, each `specifier` or `specifier#export`
+// (the `#export` form also exercises the export assertion). Absent → default.
+const probeExtra = (process.env.COMPOSE_PRELOAD_PROBE || '')
+  .split(',')
+  .map((s) => s.trim())
+  .filter(Boolean)
+  .map((entry) => {
+    const hash = entry.indexOf('#');
+    return hash === -1
+      ? { specifier: entry }
+      : { specifier: entry.slice(0, hash), expect: entry.slice(hash + 1) };
+  });
+try {
+  await preloadEagerModules([...EAGER_PRELOAD_MODULES, ...probeExtra]);
+} catch (err) {
+  // writeSync (not stderr.write) so the line is guaranteed flushed before
+  // process.exit — an async pipe write can otherwise be truncated/dropped.
+  writeSync(2, `[compose-mcp] boot aborted: ${err.message}\n`);
+  process.exit(1);
+}
+
 const transport = new StdioServerTransport();
 await server.connect(transport);
 // Server runs until stdin closes — no explicit exit needed

package/server/design-routes.js

@@ -16,6 +16,8 @@ import { randomUUID } from 'node:crypto';
 import { parseDecisionBlocks } from '../src/components/vision/designSessionState.js';
 import { StratumMcpClient } from '../lib/stratum-mcp-client.js';
 import { KNOWN_VERSIONS } from '../lib/build-stream-schema.js';
+import { getTargetRoot, resolveProjectPath } from './project-root.js';
+import { relForDisplay } from '../lib/project-paths.js';
 
 // Lazy singleton — design conversations share one stratum-mcp connection
 // across the server process lifetime. Concurrent runs are correlation-id scoped.
@@ -444,16 +446,19 @@ Output ONLY the Markdown content, no code fences.`;
         return;
       }
 
-      // Determine the output path
-      let designDocPath;
+      // Determine the output path. Resolve the absolute write target first
+      // (features may be relocated outside the root — COMP-PATHS-EXTERNAL),
+      // then derive the display-relative string from it.
+      let absPath, designDocPath;
       if (scope === 'feature' && featureCode) {
-        designDocPath = path.join('docs', 'features', featureCode, 'design.md');
+        absPath = path.join(resolveProjectPath('features'), featureCode, 'design.md');
+        designDocPath = relForDisplay(getTargetRoot(), absPath);
       } else {
         designDocPath = path.join('docs', 'design.md');
+        absPath = path.join(projectRoot, designDocPath);
       }
 
       // Guard: never overwrite an existing doc with empty content
-      const absPath = path.join(projectRoot, designDocPath);
       if (!docContent.trim()) {
         console.error('[design] Generated doc is empty — refusing to overwrite');
         res.status(500).json({ error: 'Doc generation produced empty content' });

package/server/drift-axes.js

@@ -19,6 +19,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { execSync } from 'node:child_process';
 import { diffContracts } from './contract-diff.js';
+import { resolveFeaturesPath } from '../lib/project-paths.js';
 
 // ── Threshold constants (Decision 2) ─────────────────────────────────────────
 
@@ -353,9 +354,10 @@ export function computeDriftAxes(item, projectRoot, now) {
 
   const ts = now || new Date().toISOString();
 
-  // Resolve the docs/features/<FC> directory
-  // projectRoot/docs/features/<FC>
-  const featurePath = path.join(projectRoot, 'docs', 'features', featureCode);
+  // Resolve the features/<FC> directory against projectRoot's own config
+  // (relocatable artifact paths, COMP-PATHS-EXTERNAL). Byte-identical to
+  // projectRoot/docs/features/<FC> for the in-root default.
+  const featurePath = path.join(resolveFeaturesPath(projectRoot), featureCode);
 
   const pathAxis = computePathDrift(item, projectRoot, featurePath, ts);
   const contractAxis = computeContractDrift(item, projectRoot, featurePath, ts);

package/server/feature-scaffold-routes.js

@@ -0,0 +1,82 @@
+/**
+ * feature-scaffold-routes.js — POST /api/features/scaffold.
+ *
+ * Cockpit equivalent of `compose feature <CODE>`: scaffolds docs/features/<CODE>/
+ * (feature.json + seed design.md) and the ROADMAP.md row. Reuses the typed writer
+ * addRoadmapEntry (lib/feature-writer.js) — never reimplements scaffolding and
+ * never echoes the regenerated roadmap back (the lib return is already compact).
+ *
+ * Sensitive (mutating). attachFeatureScaffoldRoutes(app, deps?) — deps is for tests.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { requireSensitiveOrPaired as requireSensitiveToken } from './security.js';
+import { addRoadmapEntry as defaultAddRoadmapEntry } from '../lib/feature-writer.js';
+import { isFeatureCode } from '../lib/feature-code.js';
+import { getTargetRoot as defaultGetProjectRoot } from './project-root.js';
+import { resolveFeaturesPathFromConfig, relForDisplay } from '../lib/project-paths.js';
+
+const DEFAULT_PHASE = 'Backlog';
+
+export function attachFeatureScaffoldRoutes(app, deps = {}) {
+  const addRoadmapEntry = deps.addRoadmapEntry || defaultAddRoadmapEntry;
+  const getProjectRoot = deps.getProjectRoot || defaultGetProjectRoot;
+
+  app.post('/api/features/scaffold', requireSensitiveToken, async (req, res) => {
+    const body = req.body || {};
+    const code = typeof body.code === 'string' ? body.code.trim().toUpperCase() : '';
+    const description = typeof body.description === 'string' ? body.description.trim() : '';
+    const phase = (typeof body.phase === 'string' && body.phase.trim())
+      || (typeof body.group === 'string' && body.group.trim())
+      || DEFAULT_PHASE;
+
+    if (!isFeatureCode(code)) {
+      return res.status(400).json({ error: 'Invalid feature code (e.g. COMP-FOO-1)' });
+    }
+    if (!description) {
+      return res.status(400).json({ error: 'description is required' });
+    }
+
+    const projectRoot = getProjectRoot();
+    try {
+      // 1. feature.json + ROADMAP.md row (compact return — no roadmap echo).
+      const result = await addRoadmapEntry(projectRoot, { code, description, phase });
+
+      // 2. Seed design.md stub (addRoadmapEntry does not write it). Idempotent.
+      //    Resolve the ABSOLUTE features dir (may be relocated) — mirror ideabox.
+      let featurePath = null;
+      try {
+        const composeJsonPath = path.join(projectRoot, '.compose', 'compose.json');
+        let cfg = {};
+        if (fs.existsSync(composeJsonPath)) {
+          try { cfg = JSON.parse(fs.readFileSync(composeJsonPath, 'utf-8')); } catch { /* default cfg */ }
+        }
+        const featuresBase = resolveFeaturesPathFromConfig(projectRoot, cfg);
+        const featureDir = path.join(featuresBase, code);
+        const designPath = path.join(featureDir, 'design.md');
+        if (!fs.existsSync(designPath)) {
+          const today = new Date().toISOString().slice(0, 10);
+          fs.mkdirSync(featureDir, { recursive: true });
+          fs.writeFileSync(designPath,
+            `# ${code}: ${description}\n\n**Status:** PLANNED\n**Created:** ${today}\n\n---\n\n## Intent\n\n${description}\n\n---\n\n## Notes\n\n_Seed design doc created by the New Feature dialog. \`compose build\` will expand it._\n`);
+        }
+        featurePath = relForDisplay(projectRoot, featureDir);
+      } catch { /* design seed is best-effort; feature.json + roadmap already written */ }
+
+      // COMPACT result — never the full roadmap (memory: MCP add_roadmap_entry echo
+      // blows the token cap; the lib return is small, keep it small here too).
+      return res.json({
+        ok: true,
+        code: result.code,
+        phase: result.phase,
+        position: result.position,
+        roadmap_path: result.roadmap_path,
+        featurePath,
+      });
+    } catch (err) {
+      const msg = err && err.message ? err.message : String(err);
+      const code409 = /already exists/i.test(msg);
+      return res.status(code409 ? 409 : 400).json({ error: msg });
+    }
+  });
+}

package/server/feature-scan.js

@@ -16,6 +16,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 import { getTargetRoot, resolveProjectPath } from './project-root.js';
+import { relForDisplay } from '../lib/project-paths.js';
 import { assertValidLinkShape } from '../lib/feature-write-guard.js';
 
 // ---------------------------------------------------------------------------
@@ -608,6 +609,11 @@ export function seedFromRoadmapGraph(store) {
 export function seedFeatures(features, store) {
   const seeded = { features: 0, updated: 0, connections: 0 };
   const featureItemMap = new Map(); // featureCode → itemId
+  const root = getTargetRoot();
+  const featuresBase = resolveProjectPath('features');
+  // Root-relative for the in-root default (relForDisplay guarantees byte-identity
+  // there); absolute when the features dir is relocated outside the workspace root.
+  const artifactPath = (feature, a) => relForDisplay(root, path.join(featuresBase, feature.name, a));
 
   // First pass: create/update items
   for (const feature of features) {
@@ -623,7 +629,7 @@ export function seedFeatures(features, store) {
         status: feature.status || 'planned',
         phase: feature.phase || 'planning',
         confidence: feature.confidence,
-        files: feature.artifacts.map(a => `docs/features/${feature.name}/${a}`),
+        files: feature.artifacts.map(a => artifactPath(feature, a)),
         ...(feature.group ? { group: feature.group } : {}),
       });
       try {
@@ -643,7 +649,7 @@ export function seedFeatures(features, store) {
       if (feature.confidence > (featureItem.confidence || 0)) {
         updates.confidence = feature.confidence;
       }
-      const newFiles = feature.artifacts.map(a => `docs/features/${feature.name}/${a}`);
+      const newFiles = feature.artifacts.map(a => artifactPath(feature, a));
       if (JSON.stringify(newFiles) !== JSON.stringify(featureItem.files || [])) {
         updates.files = newFiles;
       }

package/server/file-watcher.js

@@ -10,6 +10,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import { getTargetRoot, loadProjectConfig, ensureDataDir } from './project-root.js';
+import { resolveDocsPathFromConfig, resolveFeaturesPathFromConfig } from '../lib/project-paths.js';
 
 const PROJECT_ROOT = getTargetRoot();
 
@@ -69,7 +70,8 @@ export class FileWatcherServer {
     app.get('/api/files', (_req, res) => {
       const config = loadProjectConfig();
       const docsPrefix = config.paths?.docs || 'docs';
-      const docsDir = path.join(PROJECT_ROOT, docsPrefix);
+      // COMP-PATHS-EXTERNAL: list the RESOLVED docs dir (may be relocated).
+      const docsDir = resolveDocsPathFromConfig(PROJECT_ROOT, config);
       try {
         const files = this.listMarkdownFiles(docsDir, docsPrefix);
         res.json({ files });
@@ -164,7 +166,10 @@ export class FileWatcherServer {
           if (!filename || !fileFilter(filename)) return;
 
           const relativePath = path.join(prefix, filename);
-          const fullPath = path.join(PROJECT_ROOT, relativePath);
+          // COMP-PATHS-EXTERNAL: derive the real path from the WATCHED dir, not
+          // by re-rooting under PROJECT_ROOT — the dir may be relocated outside
+          // the workspace. Byte-identical to the old form for an in-root dir.
+          const fullPath = path.join(dir, filename);
 
           // Debounce: ignore events within 100ms of each other for the same file
           const now = Date.now();
@@ -180,10 +185,11 @@ export class FileWatcherServer {
       }
     };
 
-    // Watch docs/ — broadcast fileChanged events
+    // Watch docs/ — broadcast fileChanged events. COMP-PATHS-EXTERNAL: watch
+    // the RESOLVED absolute dir (may be relocated outside PROJECT_ROOT).
     const config = loadProjectConfig();
     const docsPrefix = config.paths?.docs || 'docs';
-    watchDir(path.join(PROJECT_ROOT, docsPrefix), docsPrefix, (relativePath, fullPath) => {
+    watchDir(resolveDocsPathFromConfig(PROJECT_ROOT, config), docsPrefix, (relativePath, fullPath) => {
       try {
         if (!fs.existsSync(fullPath)) return;
         const content = fs.readFileSync(fullPath, 'utf-8');
@@ -195,9 +201,9 @@ export class FileWatcherServer {
 
     // Watch features/ — notify for auto-reseed into vision store
     const featuresPrefix = config.paths?.features || 'docs/features';
-    watchDir(path.join(PROJECT_ROOT, featuresPrefix), featuresPrefix, (relativePath) => {
-      // Also broadcast as fileChanged (features are docs)
-      const fullPath = path.join(PROJECT_ROOT, relativePath);
+    watchDir(resolveFeaturesPathFromConfig(PROJECT_ROOT, config), featuresPrefix, (relativePath, fullPath) => {
+      // Also broadcast as fileChanged (features are docs). fullPath comes from
+      // the watched dir (COMP-PATHS-EXTERNAL) — do not re-root under PROJECT_ROOT.
       try {
         if (fs.existsSync(fullPath)) {
           const content = fs.readFileSync(fullPath, 'utf-8');