@geraldmaron/construct 1.0.3 → 1.0.5

package/lib/host-capabilities.mjs

@@ -9,7 +9,10 @@
  */
 import { execFileSync, execSync } from "node:child_process";
 import { readOpenCodeConfig } from "./opencode-config.mjs";
+import fs from "node:fs";
 import net from "node:net";
+import os from "node:os";
+import path from "node:path";
 
 const LOWEST_PORT = 0;
 const HIGHEST_PORT = 65535;
@@ -46,7 +49,8 @@ function commandVersion(command, args = ["--version"]) {
   try {
     return execFileSync(command, args, { stdio: ["ignore", "pipe", "ignore"], timeout: 5000 })
       .toString()
-      .trim();
+      .trim()
+      .split(/\r?\n/, 1)[0];
   } catch {
     return null;
   }
@@ -71,6 +75,49 @@ function versionAtLeast(version, minimum) {
   return true;
 }
 
+function detectVsCodeAvailability(homeDir = os.homedir()) {
+  const settingsCandidates = (() => {
+    const platform = os.platform();
+    if (platform === "darwin") {
+      return [
+        path.join(homeDir, "Library", "Application Support", "Code", "User", "settings.json"),
+        path.join(homeDir, "Library", "Application Support", "Code - Insiders", "User", "settings.json"),
+      ];
+    }
+    if (platform === "linux") {
+      return [
+        path.join(homeDir, ".config", "Code", "User", "settings.json"),
+        path.join(homeDir, ".config", "Code - Insiders", "User", "settings.json"),
+      ];
+    }
+    if (platform === "win32") {
+      const appData = process.env.APPDATA ?? path.join(homeDir, "AppData", "Roaming");
+      return [
+        path.join(appData, "Code", "User", "settings.json"),
+        path.join(appData, "Code - Insiders", "User", "settings.json"),
+      ];
+    }
+    return [];
+  })();
+
+  const version = commandVersion("code") || commandVersion("code-insiders");
+  const hasSettings = settingsCandidates.some((candidate) => fs.existsSync(candidate));
+  return { version, hasSettings };
+}
+
+function detectCursorAvailability(homeDir = os.homedir()) {
+  const version = commandVersion("cursor") || commandVersion("cursor-agent");
+  const hasConfig = fs.existsSync(path.join(homeDir, ".cursor", "mcp.json"));
+  return { version, hasConfig };
+}
+
+function detectCopilotAvailability(homeDir = os.homedir()) {
+  const promptsDir = path.join(homeDir, ".github", "prompts");
+  const instructionsPath = path.join(homeDir, ".github", "copilot-instructions.md");
+  const hasFiles = fs.existsSync(promptsDir) || fs.existsSync(instructionsPath);
+  return { hasFiles };
+}
+
 export function detectHostCapabilities() {
   const claudeRaw = commandVersion("claude");
   const claudeVersion = parseClaudeVersion(claudeRaw);
@@ -78,6 +125,9 @@ export function detectHostCapabilities() {
   const tmuxRaw = commandVersion("tmux", ["-V"]);
   const opencodeRaw = commandVersion("opencode");
   const codexRaw = commandVersion("codex");
+  const vscode = detectVsCodeAvailability();
+  const cursor = detectCursorAvailability();
+  const copilot = detectCopilotAvailability();
 
   return [
     {
@@ -123,6 +173,45 @@ export function detectHostCapabilities() {
         "Native profile switching is not automatic; continue in-session when dispatch is unavailable.",
       ],
     },
+    {
+      host: "VS Code",
+      availability: vscode.version || vscode.hasSettings ? "installed" : "missing",
+      version: vscode.version,
+      orchestration: "copilot-mcp",
+      promptableWorkers: false,
+      sharedTaskRuntime: "editor-session",
+      lifecycleHooks: [],
+      notes: [
+        "Construct manages GitHub Copilot MCP registrations in user settings when a VS Code settings.json already exists.",
+        "VS Code is an editor surface, not Construct's primary multi-agent runtime.",
+      ],
+    },
+    {
+      host: "Cursor",
+      availability: cursor.version || cursor.hasConfig ? "installed" : "missing",
+      version: cursor.version,
+      orchestration: "mcp-only",
+      promptableWorkers: false,
+      sharedTaskRuntime: "editor-session",
+      lifecycleHooks: [],
+      notes: [
+        "Construct manages Cursor MCP registrations in ~/.cursor/mcp.json when that file exists.",
+        "Cursor agent profiles are not generated today; use Construct through MCP-backed tools and shared project state.",
+      ],
+    },
+    {
+      host: "Copilot",
+      availability: copilot.hasFiles ? "installed" : "missing",
+      version: null,
+      orchestration: "prompt-profiles",
+      promptableWorkers: false,
+      sharedTaskRuntime: "editor-session",
+      lifecycleHooks: [],
+      notes: [
+        "Construct writes reusable prompt profiles under ~/.github/prompts/ plus a managed block in ~/.github/copilot-instructions.md.",
+        "Copilot does not expose Construct-style subagent dispatch; use the generated profiles for focused passes.",
+      ],
+    },
   ];
 }
 

package/lib/init-unified.mjs

@@ -49,6 +49,12 @@ const interactive = args.includes("--interactive") || args.includes("-i");
 const quiet = args.includes("--quiet") || args.includes("-q");
 const skipInteractive = !interactive;
 
+// Active profile selector. `--profile=<id>` writes the field into the
+// project's construct.config.json so resolveActiveProfile picks it up
+// on first run. Unknown ids are rejected with the available catalog.
+const profileArg = args.find((arg) => arg.startsWith("--profile="));
+const profileId = profileArg ? profileArg.split("=")[1] : null;
+
 const created = [];
 const skipped = [];
 
@@ -795,12 +801,29 @@ function initializeBeadsTracker(target) {
 
 async function main() {
   const projectName = inferProjectName(target);
-  
+
   const { clean } = preflight(target);
-  
+
   if (!quiet) {
     console.log(`Initializing Construct in ${path.relative(process.cwd(), target) || "."}`);
   }
+
+  // Persist --profile=<id> into construct.config.json. Validate against the
+  // curated catalog so a typo never silently falls back to rnd.
+  if (profileId) {
+    const { loadProfile, listProfiles } = await import('./profiles/loader.mjs');
+    if (!loadProfile(profileId)) {
+      console.error(`Unknown profile: ${profileId}. Available: ${listProfiles().join(', ')}`);
+      process.exit(1);
+    }
+    const { findProjectConfigPath, loadProjectConfig, writeProjectConfig, PROJECT_CONFIG_FILENAME } = await import('./config/project-config.mjs');
+    const found = findProjectConfigPath(target);
+    const cfgPath = found || path.join(target, PROJECT_CONFIG_FILENAME);
+    const cfg = found ? (loadProjectConfig(target) || { version: 1 }) : { version: 1 };
+    cfg.profile = profileId;
+    writeProjectConfig(cfgPath, cfg, { validate: true });
+    if (!quiet) console.log(`Profile set to ${profileId}.`);
+  }
   
   // Always create core Construct files
   writeStampedIfMissing({

package/lib/init-update.mjs

@@ -1,168 +1,283 @@
 #!/usr/bin/env node
 /**
- * lib/init-update.mjs — update existing projects with latest AGENTS.md template.
- * 
- * For projects that already have AGENTS.md but need to sync with the latest
- * Construct operating rules and CI enforcement.
- * 
- * Usage:
- *   node lib/init-update.mjs [--dry-run] [--cwd=path]
- *   construct init:update [--dry-run]
+ * lib/init-update.mjs — non-destructive project-standard updates and template conflict resolution.
+ *
+ * `construct init:update` helps projects adopt current Construct standards without replacing
+ * user-managed instruction files. Proposed updates are written under .cx/proposals/ for
+ * manual review and merge.
+ *
+ * checkTemplateConflicts(targetDir) compares project templates against the construct install's
+ * templates/docs/ directory. resolveTemplateConflict(conflict, resolution, targetDir) applies
+ * one of three resolutions: keep-project, use-construct, or move-to-cx-override.
  */
 
 import fs from "node:fs";
 import path from "node:path";
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import crypto from "node:crypto";
+import { constructDir } from "./paths.mjs";
 
 const args = process.argv.slice(2);
 const dryRun = args.includes("--dry-run");
-const cwdArg = args.find(arg => arg.startsWith("--cwd="));
+const cwdArg = args.find((arg) => arg.startsWith("--cwd="));
 const cwd = cwdArg ? path.resolve(cwdArg.split("=")[1]) : process.cwd();
 
-console.log(`📝 Updating project documentation in ${cwd}`);
+const REQUIRED_AGENT_SECTIONS = [
+  "Operating hierarchy",
+  "Start-of-session rules",
+  "Maintenance rules",
+  "End-of-session rules",
+  "Verification rules",
+];
 
-// Load the AGENTS.md template from project-init-shared
 async function loadAgentsTemplate(projectName) {
-  const modulePath = path.join(import.meta.dirname, 'project-init-shared.mjs');
-  try {
-    // Import the module and call the buildAgentsGuide function
-    const module = await import(modulePath);
-    if (module.buildAgentsGuide) {
-      return module.buildAgentsGuide(projectName);
-    }
-    throw new Error('Could not find buildAgentsGuide function in project-init-shared.mjs');
-  } catch (error) {
-    console.error(`❌ Failed to load AGENTS.md template: ${error.message}`);
-    process.exit(1);
+  const modulePath = path.join(import.meta.dirname, "project-init-shared.mjs");
+  const module = await import(modulePath);
+  if (!module.buildAgentsGuide) {
+    throw new Error("buildAgentsGuide not available from project-init-shared.mjs");
   }
+  return module.buildAgentsGuide(projectName);
 }
 
-function updateAgentsMd(existingContent, newTemplate) {
-  // We'll do a simple replacement for now
-  // In a real implementation, we'd parse the existing file and merge sections
-  
-  console.log(`🔄 Updating AGENTS.md`);
-  
-  if (dryRun) {
-    console.log(`📋 Dry run - would update AGENTS.md`);
-    console.log(`--- Current AGENTS.md (first 200 chars) ---`);
-    console.log(existingContent.substring(0, 200) + '...');
-    console.log(`--- New AGENTS.md (first 200 chars) ---`);
-    console.log(newTemplate.substring(0, 200) + '...');
-    return null;
+function inferProjectName(targetDir) {
+  const packagePath = path.join(targetDir, "package.json");
+  if (fs.existsSync(packagePath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(packagePath, "utf8"));
+      if (pkg.name) return pkg.name;
+    } catch { /* fall through */ }
   }
-  
-  // Backup existing file
-  const backupPath = path.join(cwd, 'AGENTS.md.backup');
-  writeFileSync(backupPath, existingContent, 'utf8');
-  console.log(`📦 Created backup at ${backupPath}`);
-  
-  // Write new template
-  const agentsPath = path.join(cwd, 'AGENTS.md');
-  writeFileSync(agentsPath, newTemplate, 'utf8');
-  console.log(`✅ Updated AGENTS.md`);
-  
-  return newTemplate;
+  return path.basename(targetDir);
 }
 
-function updateCiWorkflow(cwd) {
-  const workflowPath = path.join(cwd, '.github', 'workflows', 'ci.yml');
-  if (!existsSync(workflowPath)) {
-    console.log(`⚠️  No CI workflow found at ${workflowPath}`);
-    return false;
-  }
-  
-  let content = readFileSync(workflowPath, 'utf8');
-  
-  // Check if docs:verify is already in the workflow
-  if (content.includes('construct docs:verify')) {
-    console.log(`✅ CI workflow already has docs:verify check`);
-    return false;
+function findMissingAgentsSections(content) {
+  return REQUIRED_AGENT_SECTIONS.filter((section) => !content.toLowerCase().includes(section.toLowerCase()));
+}
+
+function ensureProposalDir(targetDir) {
+  const dir = path.join(targetDir, ".cx", "proposals");
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function writeProposal(targetDir, fileName, content) {
+  const proposalDir = ensureProposalDir(targetDir);
+  const proposalPath = path.join(proposalDir, fileName);
+  fs.writeFileSync(proposalPath, content, "utf8");
+  return proposalPath;
+}
+
+function buildAgentsProposal(existingContent, template, missingSections) {
+  const missingList = missingSections.map((section) => `- ${section}`).join("\n");
+  return [
+    "<!--",
+    "Construct init:update proposal",
+    "Review this file and merge the needed sections into AGENTS.md manually.",
+    "The original AGENTS.md was not modified.",
+    "-->",
+    "",
+    "# Proposed AGENTS.md Update",
+    "",
+    "## Why this proposal exists",
+    "",
+    "Your current `AGENTS.md` is missing these required sections:",
+    missingList,
+    "",
+    "## Current AGENTS.md",
+    "",
+    "```md",
+    existingContent.trimEnd(),
+    "```",
+    "",
+    "## Current Construct template",
+    "",
+    "```md",
+    template.trimEnd(),
+    "```",
+    "",
+  ].join("\n");
+}
+
+function buildWorkflowProposal(existingContent) {
+  const updatedContent = existingContent.replace(
+    /(\s+- run: node bin\/construct doctor\s*\n)/,
+    "$1      - run: node bin/construct docs:verify\n",
+  );
+  if (updatedContent === existingContent) return null;
+  return [
+    "# Proposed CI Workflow Update",
+    "",
+    "Add `construct docs:verify` next to the existing doctor check.",
+    "",
+    "```yaml",
+    updatedContent.trimEnd(),
+    "```",
+    "",
+  ].join("\n");
+}
+
+// ── Template conflict detection ───────────────────────────────────────────────
+
+function sha256File(filePath) {
+  const buf = fs.readFileSync(filePath);
+  return crypto.createHash('sha256').update(buf).digest('hex');
+}
+
+/**
+ * Compare project templates against the construct install's templates/docs/ directory.
+ *
+ * @param {string} targetDir — project root to inspect
+ * @returns {{ conflicts: Array<{ name, constructPath, projectPath, constructSha, projectSha }>, identical: string[], missing: string[] }}
+ */
+export function checkTemplateConflicts(targetDir) {
+  const constructTemplatesDir = path.join(constructDir(), 'templates', 'docs');
+  const projectTemplatesDir = path.join(targetDir, 'templates', 'docs');
+
+  const conflicts = [];
+  const identical = [];
+  const missing = [];
+
+  if (!fs.existsSync(constructTemplatesDir)) {
+    return { conflicts, identical, missing };
   }
-  
-  // Find the test job and add docs:verify after doctor
-  if (content.includes('node bin/construct doctor')) {
-    const updatedContent = content.replace(
-      /(\s+- run: node bin\/construct doctor\s*)/,
-      '$1      - run: node bin/construct docs:verify\n'
-    );
-    
-    if (dryRun) {
-      console.log(`📋 Dry run - would update CI workflow to include docs:verify`);
-      return true;
+
+  const constructFiles = fs.readdirSync(constructTemplatesDir).filter((f) => f.endsWith('.md'));
+
+  for (const name of constructFiles) {
+    const constructPath = path.join(constructTemplatesDir, name);
+    const projectPath = path.join(projectTemplatesDir, name);
+
+    if (!fs.existsSync(projectPath)) {
+      missing.push(name);
+      continue;
     }
-    
-    const backupPath = workflowPath + '.backup';
-    writeFileSync(backupPath, content, 'utf8');
-    writeFileSync(workflowPath, updatedContent, 'utf8');
-    console.log(`✅ Updated CI workflow to include docs:verify check`);
-    return true;
+
+    const constructSha = sha256File(constructPath);
+    const projectSha = sha256File(projectPath);
+
+    if (constructSha === projectSha) {
+      identical.push(name);
+    } else {
+      conflicts.push({ name, constructPath, projectPath, constructSha, projectSha });
+    }
+  }
+
+  return { conflicts, identical, missing };
+}
+
+/**
+ * Apply a resolution to a single template conflict.
+ *
+ * Resolutions:
+ *   'keep-project'       — do nothing; leave the project template as-is
+ *   'use-construct'      — overwrite project template with construct's version; backup original to <name>.bak
+ *   'move-to-cx-override' — copy project template to .cx/templates/docs/<name>,
+ *                           then write construct's template to templates/docs/<name>
+ *
+ * @param {{ name, constructPath, projectPath, constructSha, projectSha }} conflict
+ * @param {'keep-project'|'use-construct'|'move-to-cx-override'} resolution
+ * @param {string} targetDir
+ */
+export function resolveTemplateConflict(conflict, resolution, targetDir) {
+  const { name, constructPath, projectPath } = conflict;
+
+  if (resolution === 'keep-project') {
+    return;
+  }
+
+  if (resolution === 'use-construct') {
+    const backupPath = `${projectPath}.bak`;
+    fs.copyFileSync(projectPath, backupPath);
+    fs.copyFileSync(constructPath, projectPath);
+    return;
   }
-  
-  console.log(`⚠️  Could not find 'construct doctor' in CI workflow to add docs:verify`);
-  return false;
+
+  if (resolution === 'move-to-cx-override') {
+    const cxOverrideDir = path.join(targetDir, '.cx', 'templates', 'docs');
+    fs.mkdirSync(cxOverrideDir, { recursive: true });
+    fs.copyFileSync(projectPath, path.join(cxOverrideDir, name));
+    fs.copyFileSync(constructPath, projectPath);
+    return;
+  }
+
+  throw new Error(`Unknown resolution: ${resolution}. Expected keep-project, use-construct, or move-to-cx-override.`);
 }
 
+// ── Init update workflow ──────────────────────────────────────────────────────
+
 async function main() {
-  console.log(`\n🔍 Checking project structure...`);
-  
-  // Check for AGENTS.md
-  const agentsPath = path.join(cwd, 'AGENTS.md');
-  if (!existsSync(agentsPath)) {
-    console.log(`❌ AGENTS.md not found. Run 'construct init' first.`);
+  console.log(`Preparing Construct standards update for ${cwd}`);
+
+  const agentsPath = path.join(cwd, "AGENTS.md");
+  if (!fs.existsSync(agentsPath)) {
+    console.error("AGENTS.md not found. Run `construct init` first.");
     process.exit(1);
   }
-  
-  const existingAgents = readFileSync(agentsPath, 'utf8');
-  
-  // Get project name from package.json or directory name
-  let projectName = path.basename(cwd);
-  const packagePath = path.join(cwd, 'package.json');
-  if (existsSync(packagePath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(packagePath, 'utf8'));
-      if (pkg.name) projectName = pkg.name;
-    } catch (error) {
-      console.log(`⚠️  Could not read package.json: ${error.message}`);
+
+  const projectName = inferProjectName(cwd);
+  const existingAgents = fs.readFileSync(agentsPath, "utf8");
+  const template = await loadAgentsTemplate(projectName);
+  const missingSections = findMissingAgentsSections(existingAgents);
+
+  const planned = [];
+
+  if (missingSections.length > 0) {
+    const proposalPath = path.join(".cx", "proposals", "AGENTS.md.construct-update.md");
+    planned.push({
+      label: `AGENTS.md proposal (${missingSections.length} missing section${missingSections.length === 1 ? "" : "s"})`,
+      write() {
+        return writeProposal(cwd, "AGENTS.md.construct-update.md", buildAgentsProposal(existingAgents, template, missingSections));
+      },
+      relativePath: proposalPath,
+    });
+  }
+
+  const workflowPath = path.join(cwd, ".github", "workflows", "ci.yml");
+  if (fs.existsSync(workflowPath)) {
+    const workflowContent = fs.readFileSync(workflowPath, "utf8");
+    if (!workflowContent.includes("node bin/construct docs:verify")) {
+      const proposal = buildWorkflowProposal(workflowContent);
+      if (proposal) {
+        planned.push({
+          label: "CI workflow proposal (add docs:verify)",
+          write() {
+            return writeProposal(cwd, "ci.yml.construct-update.md", proposal);
+          },
+          relativePath: path.join(".cx", "proposals", "ci.yml.construct-update.md"),
+        });
+      }
     }
   }
-  
-  const template = await loadAgentsTemplate(projectName);
-  
-  console.log(`\n📊 Analysis:`);
-  console.log(`   • AGENTS.md found (${existingAgents.length} chars)`);
-  console.log(`   • Latest template loaded (${template.length} chars)`);
-  console.log(`   • Project name: ${projectName}`);
-  
-  // Check if AGENTS.md has documentation enforcement section
-  const hasDocEnforcement = existingAgents.includes('Documentation Rules');
-  console.log(`   • Has documentation enforcement: ${hasDocEnforcement ? '✅' : '❌'}`);
-  
-  // Check for CI workflow
-  const ciUpdated = updateCiWorkflow(cwd);
-  
-  // Update AGENTS.md if it doesn't have the latest sections
-  if (!hasDocEnforcement) {
-    updateAgentsMd(existingAgents, template);
-  } else {
-    console.log(`✅ AGENTS.md already has documentation enforcement rules`);
+
+  if (planned.length === 0) {
+    console.log("No proposals needed. The project already satisfies the current update checks.");
+    return;
   }
-  
-  console.log(`\n🎉 Update complete!`);
-  console.log(`\nNext steps:`);
-  console.log(`   1. Review the updated AGENTS.md`);
-  console.log(`   2. Run 'construct docs:verify' to test documentation checks`);
-  console.log(`   3. Commit changes: git add AGENTS.md .github/workflows/ci.yml`);
-  console.log(`   4. Push and verify CI passes`);
-  
+
+  console.log("");
+  console.log("Planned proposals:");
+  for (const item of planned) {
+    console.log(`  - ${item.label} -> ${item.relativePath}`);
+  }
+
   if (dryRun) {
-    console.log(`\n⚠️  This was a dry run. Use 'construct init:update' without --dry-run to apply changes.`);
+    console.log("");
+    console.log("Dry run only. No files were written.");
+    return;
   }
+
+  console.log("");
+  for (const item of planned) {
+    const proposalPath = item.write();
+    console.log(`Wrote proposal: ${proposalPath}`);
+  }
+
+  console.log("");
+  console.log("Review the proposal files under .cx/proposals/ and merge the needed changes manually.");
 }
 
 if (import.meta.url === `file://${process.argv[1]}`) {
-  main().catch(error => {
-    console.error(`❌ Error: ${error.message}`);
+  main().catch((error) => {
+    console.error(`Error: ${error.message}`);
     process.exit(1);
   });
-}
+}