@geraldmaron/construct 1.0.2 → 1.0.4

package/lib/hooks/read-tracker.mjs

@@ -7,63 +7,14 @@
  * @p95ms 10
  * @maxBlockingScope none (PostToolUse, non-blocking)
  */
-import { readFileSync, writeFileSync, mkdirSync, existsSync, appendFileSync } from 'fs';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
 import { createHash } from 'crypto';
 import { join, resolve } from 'path';
 import { homedir } from 'os';
+import { flushReadTrackerDeltas, recordReadDelta } from '../read-tracker-store.mjs';
 
 const CX_DIR = join(homedir(), '.cx');
 const HASH_STORE = join(CX_DIR, 'file-hashes.json');
-const EFFICIENCY_STORE = join(CX_DIR, 'session-efficiency.json');
-const WARN_FLAGS = join(CX_DIR, 'warn-flags.txt');
-const SESSION_IDLE_RESET_MS = 2 * 60 * 60 * 1000;
-const REPEATED_READ_WARNING_THRESHOLD = 5;
-const REPEATED_READ_TIER2_THRESHOLD = 8;
-const LARGE_READ_WARNING_THRESHOLD = 3;
-const TOTAL_BYTES_WARNING_THRESHOLD = 750_000;
-
-// Bound per-session `stats.files` so the read-tracking map cannot grow
-// without limit across long sessions. The hook is a fresh node process per
-// Read, so every invocation must read-mutate-write the full state — there
-// is no in-memory accumulator that would survive between calls. The LRU cap
-// drops the oldest entries by `lastReadAt`.
-
-const FILES_LRU_CAP = 200;
-
-function loadEfficiencyStats(nowIso) {
-  const fresh = {
-    sessionStartedAt: nowIso,
-    lastUpdatedAt: nowIso,
-    readCount: 0,
-    uniqueFileCount: 0,
-    repeatedReadCount: 0,
-    largeReadCount: 0,
-    totalBytesRead: 0,
-    warnings: {},
-    files: {},
-  };
-
-  try {
-    const existing = JSON.parse(readFileSync(EFFICIENCY_STORE, 'utf8'));
-    const lastUpdated = new Date(existing.lastUpdatedAt || 0).getTime();
-    if (!lastUpdated || Date.now() - lastUpdated > SESSION_IDLE_RESET_MS) return fresh;
-    return { ...fresh, ...existing, warnings: existing.warnings || {}, files: existing.files || {} };
-  } catch {
-    return fresh;
-  }
-}
-
-function appendWarning(message) {
-  try { appendFileSync(WARN_FLAGS, `${message}\n`); } catch { /* best effort */ }
-}
-
-function topRepeatedPath(files) {
-  return Object.entries(files || {})
-    .map(([filePath, value]) => ({ filePath, count: Number(value?.count || 0) }))
-    .filter((entry) => entry.count > 1)
-    .sort((a, b) => b.count - a.count || a.filePath.localeCompare(b.filePath))[0];
-}
-
 let input = {};
 try { input = JSON.parse(readFileSync(0, 'utf8')); } catch { process.exit(0); }
 
@@ -81,7 +32,6 @@ try {
   const nowIso = new Date().toISOString();
   const requestedLimit = Number(input?.tool_input?.limit || 0);
   const effectiveLimit = requestedLimit > 0 ? requestedLimit : 2000;
-  const isLargeRead = effectiveLimit > 400;
 
   mkdirSync(CX_DIR, { recursive: true });
   let store = {};
@@ -95,58 +45,17 @@ try {
     if (new Date(v.ts).getTime() < cutoff) delete store[k];
   }
 
-  const stats = loadEfficiencyStats(nowIso);
-  const existingFile = stats.files[absPath];
-  stats.readCount += 1;
-  stats.totalBytesRead += content.length;
-  if (isLargeRead) stats.largeReadCount += 1;
-  if (existingFile) {
-    stats.repeatedReadCount += 1;
-  } else {
-    stats.uniqueFileCount += 1;
-  }
-  stats.files[absPath] = {
-    count: (existingFile?.count || 0) + 1,
+  writeFileSync(HASH_STORE, JSON.stringify(store, null, 2));
+  recordReadDelta({
+    path: absPath,
     size: content.length,
-    lastReadAt: nowIso,
-    lastRequestedLimit: effectiveLimit,
-  };
+    limit: effectiveLimit,
+    ts: nowIso,
+  }, process.env);
 
-  // LRU cap: bound stats.files to FILES_LRU_CAP entries by lastReadAt so the
-  // structure does not grow without limit across long sessions.
-  const fileEntries = Object.entries(stats.files);
-  if (fileEntries.length > FILES_LRU_CAP) {
-    fileEntries.sort((a, b) => (a[1]?.lastReadAt || '').localeCompare(b[1]?.lastReadAt || ''));
-    const drop = fileEntries.length - FILES_LRU_CAP;
-    for (let i = 0; i < drop; i++) delete stats.files[fileEntries[i][0]];
+  if (process.env.CONSTRUCT_READ_TRACKER_FLUSH === '1') {
+    flushReadTrackerDeltas({ nowIso, env: process.env });
   }
-
-  if (stats.repeatedReadCount >= REPEATED_READ_WARNING_THRESHOLD && !stats.warnings.repeatedReads) {
-    const top = topRepeatedPath(stats.files);
-    const topNote = top ? ` Top repeat: ${top.filePath} (${top.count}x).` : '';
-    appendWarning(`Efficiency: ${stats.repeatedReadCount} repeated reads this session.${topNote} Use rg or construct distill before re-reading more files.`);
-    stats.warnings.repeatedReads = nowIso;
-
-    if (stats.repeatedReadCount >= REPEATED_READ_TIER2_THRESHOLD && !stats.warnings.repeatedReadsTier2) {
-      appendWarning(`Efficiency: ${stats.repeatedReadCount} repeated reads this session — consider using construct distill or rg before re-reading entire files.`);
-      stats.warnings.repeatedReadsTier2 = nowIso;
-    }
-  }
-
-  if (stats.largeReadCount >= LARGE_READ_WARNING_THRESHOLD && !stats.warnings.largeReads) {
-    appendWarning(`Efficiency: ${stats.largeReadCount} large reads this session — prefer rg/glob plus targeted reads under 400 lines.`);
-    stats.warnings.largeReads = nowIso;
-  }
-
-  if (stats.totalBytesRead >= TOTAL_BYTES_WARNING_THRESHOLD && !stats.warnings.totalBytes) {
-    appendWarning(`Efficiency: ${Math.round(stats.totalBytesRead / 1024)} KB read this session — consider distill/query-focused retrieval or compact context before continuing.`);
-    stats.warnings.totalBytes = nowIso;
-  }
-
-  stats.lastUpdatedAt = nowIso;
-
-  writeFileSync(HASH_STORE, JSON.stringify(store, null, 2));
-  writeFileSync(EFFICIENCY_STORE, JSON.stringify(stats, null, 2));
 } catch { /* best effort */ }
 
 process.exit(0);

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

@@ -591,6 +591,108 @@ async function askDocumentationQuestions() {
   return { lanes: selectedLanes, withArchitecture, withReadme };
 }
 
+// Intake collection — suggest directories to watch for context
+function discoverProjectDirs(targetPath) {
+  const dirs = [];
+  let entries;
+  try { entries = fs.readdirSync(targetPath, { withFileTypes: true }); } catch { return dirs; }
+  
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const name = entry.name;
+    // Skip hidden dirs, node_modules, build artifacts
+    if (name.startsWith('.')) continue;
+    if (name === 'node_modules') continue;
+    if (name === 'dist' || name === 'build' || name === '.next' || name === '.out') continue;
+    dirs.push(name);
+  }
+  return dirs.sort();
+}
+
+const INTAKE_DIR_PRESETS = [
+  { value: 'src', label: 'src/', reason: 'Source code — most projects put code here' },
+  { value: 'lib', label: 'lib/', reason: 'Library code' },
+  { value: 'packages', label: 'packages/', reason: 'Monorepo packages' },
+  { value: 'services', label: 'services/', reason: 'Microservices or backend services' },
+  { value: 'apps', label: 'apps/', reason: 'Monorepo apps' },
+  { value: 'docs', label: 'docs/', reason: 'Documentation source' },
+  { value: 'tests', label: 'tests/', reason: 'Test files' },
+  { value: 'spec', label: 'spec/', reason: 'Specifications' },
+  { value: 'infra', label: 'infra/', reason: 'Infrastructure code (Terraform, etc.)' },
+  { value: 'config', label: 'config/', reason: 'Configuration files' },
+  { value: 'scripts', label: 'scripts/', reason: 'Build/ops scripts' },
+  { value: 'tools', label: 'tools/', reason: 'Internal tooling' },
+];
+
+async function askIntakeCollection(targetPath, skipInteractive) {
+  if (skipInteractive) {
+    // Non-interactive: auto-detect and suggest based on what exists
+    const existingDirs = discoverProjectDirs(targetPath);
+    const selected = INTAKE_DIR_PRESETS
+      .filter(preset => existingDirs.includes(preset.value))
+      .map(p => p.value);
+    
+    if (selected.length === 0) return null;
+    
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log('  INTAKE COLLECTION');
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log('');
+    console.log(`Auto-detected ${selected.length} directory(ies) to watch for context:`);
+    for (const d of selected) console.log(`  • ${d}/`);
+    console.log('');
+    console.log('The inbox watcher will scan these directories for new files');
+    console.log('and route them through R&D triage automatically.');
+    console.log('');
+    
+    return { parentDirs: selected, maxDepth: 4 };
+  }
+  
+  // Interactive mode
+  const existingDirs = discoverProjectDirs(targetPath);
+  const presetOptions = INTAKE_DIR_PRESETS.map(p => ({
+    label: p.label,
+    value: p.value,
+    checked: existingDirs.includes(p.value),
+    description: p.reason,
+  }));
+  
+  console.log('');
+  console.log('═══════════════════════════════════════════════════════════');
+  console.log('  INTAKE COLLECTION');
+  console.log('═══════════════════════════════════════════════════════════');
+  console.log('');
+  console.log('Intake watches directories for new files and routes them');
+  console.log('through R&D triage. Select which directories to watch.');
+  console.log('(directories already found in your project are pre-checked)');
+  console.log('');
+  
+  const selected = await multiSelect({
+    title: 'Directories to Watch',
+    instructions: 'Press Enter to confirm your selection',
+    options: presetOptions,
+  });
+  
+  if (selected.length === 0) {
+    console.log('');
+    console.log('No directories selected. The inbox watcher will only scan');
+    console.log('.cx/inbox/ and docs/intake/ (built-in zones).');
+    console.log('');
+    console.log('You can always add more later with:');
+    console.log('  construct intake config set --add-dir=src');
+    console.log('');
+    return null;
+  }
+  
+  console.log('');
+  console.log(`Watching ${selected.length} directory(ies):`);
+  for (const d of selected) console.log(`  • ${d}/`);
+  console.log('');
+  
+  return { parentDirs: selected, maxDepth: 4 };
+}
+
 function buildProjectReadme(projectName) {
   return `# ${projectName}
 
@@ -824,6 +926,20 @@ async function main() {
     console.log('');
   }
   
+  // Intake collection — ask which directories to watch for context
+  console.log('[TRACE init:intake-ask]');
+  
+  const intakeConfig = await askIntakeCollection(target, skipInteractive);
+  if (intakeConfig) {
+    const { saveIntakeConfig } = await import('./intake/intake-config.mjs');
+    try {
+      saveIntakeConfig(target, intakeConfig);
+      created.push('.cx/intake-config.json');
+    } catch (err) {
+      console.warn(`⚠️  Could not write intake config: ${err.message}`);
+    }
+  }
+  
   // Ask about documentation system
   console.log('[TRACE init:docs-ask]');
   
@@ -895,7 +1011,7 @@ async function main() {
   // can compare new intake against established PRDs/RFCs/ADRs from day
   // one. Best-effort: skipped silently when Postgres + embedding model
   // aren't ready yet (DATABASE_URL unset, no ONNX cache). User can re-run
-  // `construct ingest` or `construct setup` later to seed manually.
+  // `construct ingest` or `construct init` later to seed manually.
 
   try {
     const { syncFileStateToSql } = await import('./storage/sync.mjs');
@@ -950,10 +1066,10 @@ async function main() {
     if (verbose) console.log('\nStarting services...');
     try {
       const { startServices } = await import('./service-manager.mjs');
-      const { os } = await import('node:os');
+      const { homedir } = await import('node:os');
       const { detectDockerCompose } = await import('./setup.mjs');
       
-      const homeDir = os.homedir();
+      const homeDir = homedir();
       const composeRunner = detectDockerCompose();
       
       const { results } = await startServices({