@geraldmaron/construct 1.0.3 → 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.",
+      ],
+    },
   ];
 }