@ryuenn3123/agentic-senior-core 3.0.5 → 3.0.7

package/lib/cli/utils.mjs

@@ -112,6 +112,66 @@ export async function copyDirectory(sourceDirectoryPath, targetDirectoryPath) {
   }
 }
 
+/**
+ * Synchronizes a single file between source and target, returning the operation status.
+ */
+export async function syncFile(sourcePath, targetPath) {
+  if (!(await pathExists(sourcePath))) return { status: 'skipped' };
+
+  if (!(await pathExists(targetPath))) {
+    await ensureDirectory(path.dirname(targetPath));
+    await fs.copyFile(sourcePath, targetPath);
+    return { status: 'created' };
+  }
+
+  const sourceContent = await fs.readFile(sourcePath);
+  const targetContent = await fs.readFile(targetPath);
+
+  if (sourceContent.equals(targetContent)) {
+    return { status: 'unchanged' };
+  }
+
+  await fs.copyFile(sourcePath, targetPath);
+  return { status: 'updated' };
+}
+
+/**
+ * Intelligent MCP configuration synchronization.
+ * Merges the agentic-senior-core server into existing config or creates new.
+ */
+async function syncMcpConfig(mcpJsonPath, templateConfig) {
+  const topKey = Object.keys(templateConfig)[0]; // e.g. "mcpServers" or "servers"
+  const serverName = 'agentic-senior-core';
+  const templateServer = templateConfig[topKey][serverName];
+
+  if (!(await pathExists(mcpJsonPath))) {
+    await ensureDirectory(path.dirname(mcpJsonPath));
+    await fs.writeFile(mcpJsonPath, JSON.stringify(templateConfig, null, 2) + '\n', 'utf8');
+    return { status: 'created' };
+  }
+
+  try {
+    const existingContent = await fs.readFile(mcpJsonPath, 'utf8');
+    const config = JSON.parse(existingContent);
+    
+    if (!config[topKey]) config[topKey] = {};
+    
+    const existingServer = config[topKey][serverName];
+
+    if (JSON.stringify(existingServer) === JSON.stringify(templateServer)) {
+       return { status: 'unchanged' };
+    }
+
+    config[topKey][serverName] = templateServer;
+    await fs.writeFile(mcpJsonPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+    return { status: 'updated' };
+  } catch {
+    // If JSON is broken, overwrite it as a last resort to recovery
+    await fs.writeFile(mcpJsonPath, JSON.stringify(templateConfig, null, 2) + '\n', 'utf8');
+    return { status: 'updated' };
+  }
+}
+
 function toPosixRelativePath(relativePath) {
   return relativePath.split(path.sep).join('/');
 }
@@ -281,9 +341,7 @@ export async function analyzeManagedGovernanceSurface(
     managedTargetFileCount: targetManifest.files.size,
     managedTargetDirectoryCount: targetManifest.directories.size,
   };
-}
-
-export async function copyGovernanceAssetsToTarget(
+}export async function copyGovernanceAssetsToTarget(
   resolvedTargetDirectoryPath,
   options = {}
 ) {
@@ -294,6 +352,9 @@ export async function copyGovernanceAssetsToTarget(
     : null;
   const deletedManagedFiles = [];
   const deletedManagedDirectories = [];
+  const createdFiles = [];
+  const updatedFiles = [];
+  const unchangedFiles = [];
 
   for (const sourceDirectoryName of directoryCopies) {
     const sourceDirectoryPath = path.join(REPO_ROOT, sourceDirectoryName);
@@ -301,7 +362,16 @@ export async function copyGovernanceAssetsToTarget(
       continue;
     }
 
-    await copyDirectory(sourceDirectoryPath, path.join(resolvedTargetDirectoryPath, sourceDirectoryName));
+    const sourceTree = await collectRelativeTreeEntries(sourceDirectoryPath, sourceDirectoryName);
+    for (const relativeFilePath of sourceTree.files) {
+      const sourcePath = path.join(REPO_ROOT, ...relativeFilePath.split('/'));
+      const targetPath = path.join(resolvedTargetDirectoryPath, ...relativeFilePath.split('/'));
+      const syncResult = await syncFile(sourcePath, targetPath);
+      
+      if (syncResult.status === 'created') createdFiles.push(relativeFilePath);
+      else if (syncResult.status === 'updated') updatedFiles.push(relativeFilePath);
+      else if (syncResult.status === 'unchanged') unchangedFiles.push(relativeFilePath);
+    }
   }
 
   for (const entryPointFileName of entryPointFiles) {
@@ -316,8 +386,10 @@ export async function copyGovernanceAssetsToTarget(
       continue;
     }
 
-    await ensureDirectory(path.dirname(targetFilePath));
-    await fs.copyFile(sourceFilePath, targetFilePath);
+    const syncResult = await syncFile(sourceFilePath, targetFilePath);
+    if (syncResult.status === 'created') createdFiles.push(entryPointFileName);
+    else if (syncResult.status === 'updated') updatedFiles.push(entryPointFileName);
+    else if (syncResult.status === 'unchanged') unchangedFiles.push(entryPointFileName);
   }
 
   if (shouldPruneManagedSurface && managedSurfacePlan) {
@@ -346,16 +418,14 @@ export async function copyGovernanceAssetsToTarget(
     const projectName = path.basename(resolvedTargetDirectoryPath);
     const mcpArgs = ['./scripts/mcp-server.mjs'];
 
-    // Ensure the MCP server entrypoint exists in the target project.
-    // The workspace MCP configs point at ./scripts/mcp-server.mjs, so we must copy it.
     const sourceMcpServerPath = path.join(REPO_ROOT, 'scripts', 'mcp-server.mjs');
     const targetMcpServerPath = path.join(resolvedTargetDirectoryPath, 'scripts', 'mcp-server.mjs');
-    await ensureDirectory(path.dirname(targetMcpServerPath));
-    await fs.copyFile(sourceMcpServerPath, targetMcpServerPath);
+    const mcpServerSync = await syncFile(sourceMcpServerPath, targetMcpServerPath);
+    if (mcpServerSync.status === 'created') createdFiles.push('scripts/mcp-server.mjs');
+    else if (mcpServerSync.status === 'updated') updatedFiles.push('scripts/mcp-server.mjs');
 
     // 1. VS Code (Workspace Local Settings)
-    const vscodeDirPath = path.join(resolvedTargetDirectoryPath, '.vscode');
-    const vscodeMcpJsonPath = path.join(vscodeDirPath, 'mcp.json');
+    const vscodeMcpJsonPath = path.join(resolvedTargetDirectoryPath, '.vscode', 'mcp.json');
     const vscodeWorkspaceMcpConfig = {
       servers: {
         'agentic-senior-core': {
@@ -366,15 +436,12 @@ export async function copyGovernanceAssetsToTarget(
         },
       },
     };
-
-    if (!(await pathExists(vscodeMcpJsonPath))) {
-      await ensureDirectory(vscodeDirPath);
-      await fs.writeFile(vscodeMcpJsonPath, JSON.stringify(vscodeWorkspaceMcpConfig, null, 2) + '\n', 'utf8');
-    }
+    const vscodeSync = await syncMcpConfig(vscodeMcpJsonPath, vscodeWorkspaceMcpConfig);
+    if (vscodeSync.status === 'created') createdFiles.push('.vscode/mcp.json');
+    else if (vscodeSync.status === 'updated') updatedFiles.push('.vscode/mcp.json');
 
     // 2. Cursor (Workspace Local Settings)
-    const cursorDirPath = path.join(resolvedTargetDirectoryPath, '.cursor');
-    const cursorMcpJsonPath = path.join(cursorDirPath, 'mcp.json');
+    const cursorMcpJsonPath = path.join(resolvedTargetDirectoryPath, '.cursor', 'mcp.json');
     const cursorWorkspaceMcpConfig = {
       mcpServers: {
         'agentic-senior-core': {
@@ -384,15 +451,12 @@ export async function copyGovernanceAssetsToTarget(
         },
       },
     };
-
-    if (!(await pathExists(cursorMcpJsonPath))) {
-      await ensureDirectory(cursorDirPath);
-      await fs.writeFile(cursorMcpJsonPath, JSON.stringify(cursorWorkspaceMcpConfig, null, 2) + '\n', 'utf8');
-    }
+    const cursorSync = await syncMcpConfig(cursorMcpJsonPath, cursorWorkspaceMcpConfig);
+    if (cursorSync.status === 'created') createdFiles.push('.cursor/mcp.json');
+    else if (cursorSync.status === 'updated') updatedFiles.push('.cursor/mcp.json');
 
     // 3. Zed IDE (Workspace Local Settings)
-    const zedDirPath = path.join(resolvedTargetDirectoryPath, '.zed');
-    const zedSettingsPath = path.join(zedDirPath, 'settings.json');
+    const zedSettingsPath = path.join(resolvedTargetDirectoryPath, '.zed', 'settings.json');
     const zedMcpConfig = {
       context_servers: {
         'agentic-senior-core': {
@@ -404,22 +468,22 @@ export async function copyGovernanceAssetsToTarget(
     };
 
     if (!(await pathExists(zedSettingsPath))) {
-      await ensureDirectory(zedDirPath);
+      await ensureDirectory(path.dirname(zedSettingsPath));
       await fs.writeFile(zedSettingsPath, JSON.stringify(zedMcpConfig, null, 2) + '\n', 'utf8');
+      createdFiles.push('.zed/settings.json');
     } else {
       try {
         const existingZedContent = await fs.readFile(zedSettingsPath, 'utf8');
         const parsedZedSettings = JSON.parse(existingZedContent);
-        if (!parsedZedSettings.context_servers) {
-          parsedZedSettings.context_servers = {};
-        }
-        if (!parsedZedSettings.context_servers['agentic-senior-core']) {
-          parsedZedSettings.context_servers['agentic-senior-core'] = zedMcpConfig.context_servers['agentic-senior-core'];
+        if (!parsedZedSettings.context_servers) parsedZedSettings.context_servers = {};
+        
+        const templateServer = zedMcpConfig.context_servers['agentic-senior-core'];
+        if (JSON.stringify(parsedZedSettings.context_servers['agentic-senior-core']) !== JSON.stringify(templateServer)) {
+          parsedZedSettings.context_servers['agentic-senior-core'] = templateServer;
           await fs.writeFile(zedSettingsPath, JSON.stringify(parsedZedSettings, null, 2) + '\n', 'utf8');
+          updatedFiles.push('.zed/settings.json');
         }
-      } catch {
-        // Fallback or ignore if user has broken JSON
-      }
+      } catch { /* Ignore malformed Zed JSON */ }
     }
 
     // 4. Antigravity / Gemini (Global Settings)
@@ -441,28 +505,29 @@ export async function copyGovernanceAssetsToTarget(
           
           const safeProjectName = projectName.replace(/[^a-zA-Z0-9_-]/g, '-');
           const uniqueServerName = `agentic-senior-core-${safeProjectName}`;
-          
-          // For global configs, we use absolute path for cwd
-          geminiConfig.mcpServers[uniqueServerName] = {
+          const templateServer = {
             command: 'node',
             args: mcpArgs,
             cwd: resolvedTargetDirectoryPath,
           };
           
-          await fs.writeFile(globalGeminiMcpPath, JSON.stringify(geminiConfig, null, 2) + '\n', 'utf8');
+          if (JSON.stringify(geminiConfig.mcpServers[uniqueServerName]) !== JSON.stringify(templateServer)) {
+             geminiConfig.mcpServers[uniqueServerName] = templateServer;
+             await fs.writeFile(globalGeminiMcpPath, JSON.stringify(geminiConfig, null, 2) + '\n', 'utf8');
+          }
         }
-      } catch {
-        // Ignore global injection errors
-      }
+      } catch { /* Ignore global injection errors */ }
     }
   }
 
   return {
     deletedManagedFiles,
     deletedManagedDirectories,
+    createdFiles,
+    updatedFiles,
+    unchangedFiles,
     managedSurfacePlan,
   };
-
 }
 
 export async function askChoice(promptMessage, options, userInterface) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryuenn3123/agentic-senior-core",
-  "version": "3.0.5",
+  "version": "3.0.7",
   "type": "module",
   "description": "Force your AI Agent to code like a Staff Engineer, not a Junior.",
   "bin": {

package/scripts/validate.mjs

@@ -211,19 +211,19 @@ const REQUIRED_UNIVERSAL_SOP_SNIPPETS = [
     snippets: [
       '### 15. Universal SOP Consolidation',
       'Coding flow is blocked if `docs/architecture-decision-record.md` (or `docs/Architecture-Decision-Record.md`) is missing',
-      'UI implementation flow is blocked if `docs/DESIGN.md` is missing',
+      'UI implementation flow is blocked if `docs/DESIGN.md` or `docs/design-intent.json` is missing',
     ],
   },
   {
     path: '.agent-context/prompts/review-code.md',
     snippets: [
-      'Enforce Universal SOP hard gate: block coding flow when required project docs are missing (`docs/architecture-decision-record.md`, and for UI scope `docs/DESIGN.md`).',
+      'Enforce Universal SOP hard gate: block coding flow when required project docs are missing (`docs/architecture-decision-record.md`, and for UI scope `docs/DESIGN.md` plus `docs/design-intent.json`).',
     ],
   },
   {
     path: '.agent-context/prompts/refactor.md',
     snippets: [
-      '6. Enforce Universal SOP hard gate: stop implementation if `docs/architecture-decision-record.md` is missing, and for UI scope stop if `docs/DESIGN.md` is missing.',
+      '6. Enforce Universal SOP hard gate: stop implementation if `docs/architecture-decision-record.md` is missing, and for UI scope stop if `docs/DESIGN.md` or `docs/design-intent.json` is missing.',
     ],
   },
   {
@@ -231,7 +231,7 @@ const REQUIRED_UNIVERSAL_SOP_SNIPPETS = [
     snippets: [
       'Universal SOP hard block policy:',
       'Hard block: do not write application code until docs/project-brief.md and docs/architecture-decision-record.md exist.',
-      'For UI scope: if docs/DESIGN.md is missing, execute bootstrap-design prompt before implementing UI surfaces.',
+      'For UI scope: if docs/DESIGN.md or docs/design-intent.json is missing, execute bootstrap-design prompt before implementing UI surfaces.',
     ],
   },
 ];
@@ -250,10 +250,22 @@ const REQUIRED_TEMPLATE_FREE_BOOTSTRAP_SNIPPETS = [
     snippets: [
       'Project docs will be authored dynamically by your IDE assistant from these prompts.',
       'bootstrap-project-context.md',
+      'Seed docs:',
       'I prepared dynamic synthesis bootstrap prompts',
     ],
   },
 ];
+const REQUIRED_UPGRADE_UI_CONTRACT_WARNING_SNIPPETS = [
+  {
+    path: 'lib/cli/commands/upgrade.mjs',
+    snippets: [
+      'UI/frontend scope was detected, but the dynamic design contract is incomplete:',
+      'docs/design-intent.json',
+      'Upgrade synchronizes governance assets, but it does not author project-specific design docs automatically.',
+      'collectProjectMarkers',
+    ],
+  },
+];
 const FORBIDDEN_TEMPLATE_BOOTSTRAP_SNIPPETS = [
   {
     path: 'lib/cli/project-scaffolder.mjs',
@@ -1021,6 +1033,28 @@ async function validateTemplateFreeBootstrapCoverage() {
   }
 }
 
+async function validateUpgradeUiContractWarningCoverage() {
+  console.log('\nChecking upgrade UI contract warning coverage...');
+
+  for (const coverageRule of REQUIRED_UPGRADE_UI_CONTRACT_WARNING_SNIPPETS) {
+    const absoluteCoveragePath = join(ROOT_DIR, coverageRule.path);
+
+    if (!(await fileExists(absoluteCoveragePath))) {
+      fail(`Missing upgrade UI contract warning source: ${coverageRule.path}`);
+      continue;
+    }
+
+    const coverageContent = await readTextFile(absoluteCoveragePath);
+    for (const requiredSnippet of coverageRule.snippets) {
+      if (coverageContent.includes(requiredSnippet)) {
+        pass(`${coverageRule.path} includes upgrade UI contract warning snippet: ${requiredSnippet}`);
+      } else {
+        fail(`${coverageRule.path} is missing upgrade UI contract warning snippet: ${requiredSnippet}`);
+      }
+    }
+  }
+}
+
 async function validateDeterministicBoundaryEnforcementCoverage() {
   console.log('\nChecking deterministic boundary enforcement coverage...');
 
@@ -1289,6 +1323,7 @@ async function main() {
   await validateStackResearchEngineCoverage();
   await validateUniversalSopConsolidationCoverage();
   await validateTemplateFreeBootstrapCoverage();
+  await validateUpgradeUiContractWarningCoverage();
   await validateDeterministicBoundaryEnforcementCoverage();
   await validateStackResearchSnapshotState();
   await validateMcpConfiguration();