peaks-loop 4.0.19 → 4.0.21

package/dist/services/doctor/doctor-service/checks/codegraph-capability.js

@@ -6,49 +6,171 @@
  * Fails when the version drifts, when the binary is missing, or
  * when the package is not resolvable at all.
  *
+ * Slice rid-CG-003 (spike follow-up #3): also detects which managed
+ * codegraph directory is in use — `.peaks/.codegraph/` (preferred)
+ * or root `.codegraph/` (legacy) — via the injected `managedPathProbe`.
+ * The CG-007 yarn-pnp fallback is preserved as the package-resolution
+ * default; the managed-path probe defaults to the same fs-walk-style
+ * helper and is independently injectable for tests.
+ *
  * The probe is injected so tests do not depend on the real
  * `node_modules` resolution; the default probe uses
  * `createRequire(import.meta.url)` to find the package.
  */
-import { existsSync } from 'node:fs';
-import { dirname, resolve as resolvePath } from 'node:path';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join, resolve as resolvePath } from 'node:path';
 import { createRequire } from 'node:module';
 import { getErrorMessage } from 'peaks-loop-shared/result';
+import { resolveCodegraphProjectRoot } from '../../../codegraph/codegraph-service.js';
 const CODEGRAPH_EXPECTED_VERSION = '0.7.10';
+const CODEGRAPH_PACKAGE_NAME = '@colbymchenry/codegraph';
+function findCodegraphPackageJsonFallback(startDir) {
+    // Slice rid-CG-007 (downstream safety): yarn-pnp / pnpm-strict /
+    // sub-package consumers may not expose `@colbymchenry/codegraph` to
+    // `createRequire(import.meta.url).resolve`. The fallback walks up
+    // the directory tree from `startDir` looking for
+    // `node_modules/@colbymchenry/codegraph/package.json`.
+    //
+    // Pinned at <=8 levels so the walk is bounded and the check never
+    // becomes O(repo-size) on a misconfigured consumer.
+    const MAX_DEPTH = 8;
+    let current = startDir;
+    for (let depth = 0; depth < MAX_DEPTH && current !== null; depth += 1) {
+        const candidate = join(current, 'node_modules', CODEGRAPH_PACKAGE_NAME, 'package.json');
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return null;
+}
 function defaultCodegraphProbe() {
     const require = createRequire(import.meta.url);
-    const packagePath = require.resolve('@colbymchenry/codegraph/package.json');
-    const pkg = require(packagePath);
-    const binaryPath = resolvePath(dirname(packagePath), 'dist', 'bin', 'codegraph.js');
-    return {
+    let packagePath;
+    try {
+        packagePath = require.resolve(`${CODEGRAPH_PACKAGE_NAME}/package.json`);
+    }
+    catch (primaryError) {
+        // Fall back to an fs walk from the cwd. This covers
+        // yarn-pnp, pnpm-strict, and sub-package consumers whose
+        // require-resolve graph does not surface the package through
+        // `createRequire(import.meta.url)` even when the package is
+        // physically installed.
+        const fallback = findCodegraphPackageJsonFallback(process.cwd());
+        if (fallback === null) {
+            // Re-throw the original require.resolve error so the caller
+            // sees the canonical failure message — the fallback path is
+            // best-effort, not a replacement.
+            throw primaryError;
+        }
+        packagePath = fallback;
+    }
+    let version = 'unknown';
+    try {
+        const pkgRaw = readFileSync(packagePath, 'utf8');
+        const parsed = JSON.parse(pkgRaw);
+        version = parsed.version ?? 'unknown';
+    }
+    catch {
+        // Fall through with version='unknown'; the binary-existence
+        // check below is the load-bearing assertion.
+    }
+    let binaryPath;
+    try {
+        binaryPath = resolvePath(dirname(packagePath), 'dist', 'bin', 'codegraph.js');
+    }
+    catch {
+        binaryPath = '';
+    }
+    let binaryExists = false;
+    if (binaryPath.length > 0) {
+        try {
+            binaryExists = statSync(binaryPath).isFile();
+        }
+        catch {
+            binaryExists = false;
+        }
+    }
+    const result = {
         packagePath,
-        version: pkg.version ?? 'unknown',
+        version,
         binaryPath,
-        binaryExists: existsSync(binaryPath)
+        binaryExists,
+        // Slice rid-CG-003 — resolve the managed codegraph directory
+        // relative to the cwd the doctor itself was invoked from.
+        // Best-effort: when the operator ran `peaks doctor` outside a
+        // project (cwd has neither `.peaks/.codegraph/` nor
+        // `.codegraph/`) we still report `fresh-preferred` so the check
+        // message names the canonical future location.
+        managedPath: detectManagedCodegraphPath(process.cwd())
     };
+    return result;
+}
+/**
+ * Slice rid-CG-003 — pure wrapper over `resolveCodegraphProjectRoot`
+ * that returns a probe-shaped managed-path payload (or null when
+ * the cwd does not look like a peaks project root).
+ */
+function detectManagedCodegraphPath(cwd) {
+    try {
+        const location = resolveCodegraphProjectRoot(cwd);
+        return {
+            source: location.source,
+            codegraphDir: location.codegraphDir,
+            cwd: location.cwd
+        };
+    }
+    catch {
+        return null;
+    }
 }
-function runCheck(probe) {
+function renderManagedPathSuffix(managedPath) {
+    if (!managedPath) {
+        return '';
+    }
+    if (managedPath.source === 'preferred') {
+        return `; managed path: ${managedPath.codegraphDir} (preferred .peaks/.codegraph/)`;
+    }
+    if (managedPath.source === 'legacy') {
+        return `; managed path: ${managedPath.codegraphDir} (legacy root .codegraph/ — consider moving to .peaks/.codegraph/)`;
+    }
+    return `; managed path: ${managedPath.codegraphDir} (fresh-preferred — no codegraph dir yet; next init will create it)`;
+}
+function runCheck(probe, managedPathProbe) {
     try {
         const result = probe();
+        const managedPath = managedPathProbe();
         const versionOk = result.version === CODEGRAPH_EXPECTED_VERSION;
+        const managedPathSuffix = renderManagedPathSuffix(managedPath);
         if (!versionOk) {
+            // rid-CG-007: downstream consumers may pull a different
+            // version via yarn-pnp / pnpm-strict. Surface as a warning
+            // (ok: false, severity: warning) so the check does NOT flip
+            // the doctor exit code. Upstream 0.7.x binaries are wire-
+            // compatible with 0.7.10 for the subset peaks-loop exercises
+            // (status / init / index / query / files / context / affected).
             return [{
                     id: 'capability:codegraph',
                     ok: false,
-                    message: `@colbymchenry/codegraph version mismatch: expected ${CODEGRAPH_EXPECTED_VERSION}, resolved ${result.version} at ${result.packagePath}`
+                    severity: 'warning',
+                    message: `@colbymchenry/codegraph version drift: expected ${CODEGRAPH_EXPECTED_VERSION}, resolved ${result.version} at ${result.packagePath} — peaks-loop uses an allow-list of subcommands and tolerates 0.7.x wire-compat. Run \`pnpm install @colbymchenry/codegraph@${CODEGRAPH_EXPECTED_VERSION}\` to pin.${managedPathSuffix}`
                 }];
         }
         if (!result.binaryExists) {
             return [{
                     id: 'capability:codegraph',
                     ok: false,
-                    message: `@colbymchenry/codegraph@${result.version} resolved at ${result.packagePath} but binary is missing at ${result.binaryPath}`
+                    message: `@colbymchenry/codegraph@${result.version} resolved at ${result.packagePath} but binary is missing at ${result.binaryPath}${managedPathSuffix}`
                 }];
         }
         return [{
                 id: 'capability:codegraph',
                 ok: true,
-                message: `@colbymchenry/codegraph@${result.version} resolves with binary at ${result.binaryPath}`
+                message: `@colbymchenry/codegraph@${result.version} resolves with binary at ${result.binaryPath}${managedPathSuffix}`
             }];
     }
     catch (error) {
@@ -61,7 +183,11 @@ function runCheck(probe) {
 }
 function run({ options }) {
     const probe = options.codegraphProbe ?? defaultCodegraphProbe;
-    return runCheck(probe);
+    const managedPathProbe = options.codegraphManagedPathProbe ?? defaultCodegraphManagedPathProbe;
+    return runCheck(probe, managedPathProbe);
+}
+function defaultCodegraphManagedPathProbe() {
+    return detectManagedCodegraphPath(process.cwd());
 }
 export const check = {
     name: 'codegraph-capability',

package/dist/services/doctor/doctor-service/types.d.ts

@@ -56,11 +56,27 @@ export type DoctorReport = {
         warnings: number;
     };
 };
+export type CodegraphManagedPathInfo = {
+    source: 'preferred' | 'legacy' | 'fresh-preferred';
+    codegraphDir: string;
+    cwd: string;
+};
 export type CodegraphCapabilityProbe = {
     packagePath: string;
     version: string;
     binaryPath: string;
     binaryExists: boolean;
+    /**
+     * Slice rid-CG-003 — preferred-path resolution result. When the
+     * probe can detect `.peaks/.codegraph/` or `.codegraph/` inside
+     * `process.cwd()` it sets `managedPath`; otherwise null (e.g.
+     * when the operator invoked `peaks doctor` outside a project).
+     *
+     * `source: 'preferred'`     — `.peaks/.codegraph/` exists
+     * `source: 'legacy'`        — only `.codegraph/` exists
+     * `source: 'fresh-preferred'` — neither exists; defaults to preferred
+     */
+    managedPath: CodegraphManagedPathInfo | null;
 };
 export type DistVersionComparison = {
     dist: string | null;
@@ -190,6 +206,15 @@ export type DoctorOptions = {
     schemasBaseDir?: string;
     skillsBaseDir?: string;
     codegraphProbe?: () => CodegraphCapabilityProbe;
+    /**
+     * Slice rid-CG-003 — optional override for the managed-codegraph
+     * path detection inside the `capability:codegraph` check. When
+     * omitted, the check uses the default fs helper
+     * (`resolveCodegraphProjectRoot(process.cwd())`). Tests inject a
+     * custom probe to drive preferred / legacy / fresh-preferred
+     * outcomes without monkey-patching `process.cwd()`.
+     */
+    codegraphManagedPathProbe?: () => CodegraphManagedPathInfo | null;
     skillPresenceProbe?: () => DoctorSkillPresence | null;
     skillPresenceFreshnessThresholdMs?: number;
     statusLineInstalledProbe?: () => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peaks-loop",
-  "version": "4.0.19",
+  "version": "4.0.21",
   "description": "Loop Engineering CLI — workflow primitive / loop guards / evaluators / slice orchestration",
   "author": "SquabbyZ",
   "keywords": [
@@ -101,10 +101,10 @@
     "headroom-ai": "0.22.4",
     "yaml": "^2.9.0",
     "zod": "^3.25.76",
-    "peaks-loop-internal-runtime": "4.0.0",
-    "peaks-loop-mut": "0.1.22",
-    "peaks-loop-shared": "0.0.50",
-    "peaks-loop-shared-channel": "0.0.26"
+    "peaks-loop-internal-runtime": "0.0.6",
+    "peaks-loop-mut": "0.1.23",
+    "peaks-loop-shared": "0.0.55",
+    "peaks-loop-shared-channel": "0.0.27"
   },
   "devDependencies": {
     "@changesets/cli": "2.31.1",