@mjasnikovs/pi-task 0.40.31 → 0.40.33

package/dist/workers/docs-core.js

@@ -549,9 +549,11 @@ function docsRawCached(cache, pkg, profile, query, ensureIndexed, retrieveChunks
 }
 function docsRawUncached(pkg, profile, cacheError, autoInstalled) {
     const parts = [];
+    // Already entry-first, and already past the selection rules: assembling that
+    // order here needed the entry compared against a list the walker spells with
+    // its own resolved paths, and a miss read as "a rule dropped it".
     const surfaceFiles = collectFiles(pkg, profile).surface;
-    const entryFirst = pkg.entry ? [pkg.entry, ...surfaceFiles.filter(f => f !== pkg.entry)] : surfaceFiles;
-    for (const abs of entryFirst) {
+    for (const abs of surfaceFiles) {
         let raw;
         try {
             raw = fs.readFileSync(abs, 'utf8');

package/dist/workers/docs-index.js

@@ -58,9 +58,14 @@ function computeContentHash(pkg, profile, supplements = []) {
     hash.update(Buffer.from(chunkerFingerprint(), 'utf8'));
     hash.update(ZERO_SEP);
     // Source text, the same trick as `declSplitRe.source`: the fingerprint moves
-    // whenever the selection rule does, with nothing to remember to bump.
+    // whenever the selection rule does, with nothing to remember to bump. The
+    // walker is here because it decides which files EXIST to be selected, and it
+    // sits one level below `String(ingestBody)` — the level three earlier fixes
+    // hid in.
     hash.update(Buffer.from(`${String(profile.isSurfaceFile)}\u0000${String(profile.selectFiles)}`
-        + `\u0000${String(dropDeadMajors)}`, 'utf8'));
+        + `\u0000${String(dropDeadMajors)}\u0000${String(walkSurface)}`
+        + `\u0000${String(withinPackage)}\u0000${String(entryFirst)}`
+        + `\u0000${profile.skipDirs.join(',')}`, 'utf8'));
     hash.update(ZERO_SEP);
     // The extractor and the writer, by source. Surfacing only `pkg.entry` below
     // leaves a package cached whenever a fix moves some OTHER module — the
@@ -91,8 +96,13 @@ function computeContentHash(pkg, profile, supplements = []) {
     return hash.digest('hex');
 }
 function walkSurface(root, profile) {
-    const out = [];
+    // A set, not a list: two links to one file are one file, and the uncached
+    // path prints this list into a single already-truncated blob.
+    const out = new Set();
     const stack = [root];
+    // A directory symlink is followed by its resolved target, so one pointing at
+    // an ancestor inside `root` walks the same subtree forever without this.
+    const walked = new Set([root]);
     while (stack.length) {
         const dir = stack.pop();
         let entries;
@@ -107,30 +117,54 @@ function walkSurface(root, profile) {
                 continue;
             const full = path.join(dir, entry.name);
             if (entry.isSymbolicLink()) {
+                let stat;
                 let realPath;
                 try {
                     realPath = fs.realpathSync(full);
+                    stat = fs.statSync(realPath);
                 }
                 catch {
                     continue;
                 }
-                const relReal = path.relative(root, realPath);
-                if (relReal.startsWith('..'))
+                if (!withinPackage(root, realPath, profile))
                     continue;
-                const stat = fs.statSync(realPath);
-                if (stat.isDirectory())
+                if (stat.isDirectory()) {
+                    if (walked.has(realPath))
+                        continue;
+                    walked.add(realPath);
                     stack.push(realPath);
-                else if (stat.isFile() && profile.isSurfaceFile(realPath))
-                    out.push(realPath);
+                    // Surface-ness is the visible name's, identity is the target's:
+                    // `index.d.ts -> src/impl.ts` is what a consumer imports, and
+                    // `helpers_test.go -> helpers.go` is still a test file.
+                }
+                else if (stat.isFile() && profile.isSurfaceFile(entry.name))
+                    out.add(realPath);
                 continue;
             }
-            if (entry.isDirectory())
+            if (entry.isDirectory()) {
+                if (walked.has(full))
+                    continue;
+                walked.add(full);
                 stack.push(full);
+            }
             else if (entry.isFile() && profile.isSurfaceFile(entry.name))
-                out.push(full);
+                out.add(full);
         }
     }
-    return out.sort();
+    return [...out].sort();
+}
+/**
+ * Is this symlink target part of the package, by the same rules its own tree obeys?
+ *
+ * The link's NAME cleared `skipDirs`; the path it resolves to has to as well, or
+ * `deps -> node_modules` files another package's declarations under this one's
+ * name and version banner.
+ */
+function withinPackage(root, realPath, profile) {
+    const rel = path.relative(root, realPath);
+    if (rel.startsWith('..'))
+        return false;
+    return !rel.split(path.sep).some(seg => profile.skipDirs.includes(seg));
 }
 /**
  * Drop a `.d.cts` / `.d.mts` that sits beside a `.d.ts` of the same name.
@@ -188,10 +222,48 @@ function dropDeadMajors(files, root, version) {
 export function collectFiles(pkg, profile) {
     const walked = walkSurface(pkg.root, profile);
     const surface = dropDeadMajors(walked, pkg.root, pkg.version);
-    return {
-        surface: profile.selectFiles ? profile.selectFiles(surface, pkg) : surface,
-        readme: pkg.readme
-    };
+    const selected = profile.selectFiles ? profile.selectFiles(surface, pkg) : surface;
+    return { surface: entryFirst(selected, walked, pkg), readme: pkg.readme };
+}
+/** The list's own spelling of `entry`, resolving links only if the plain compare misses. */
+function sameFile(files, entry) {
+    const direct = files.find(f => f === entry);
+    if (direct !== undefined)
+        return direct;
+    const real = realpathOr(entry);
+    return files.find(f => f === real || realpathOr(f) === real) ?? null;
+}
+function realpathOr(file) {
+    try {
+        return fs.realpathSync(file);
+    }
+    catch {
+        return file;
+    }
+}
+/**
+ * The manifest's entry at the head, and back in the list when the walk never
+ * offered it.
+ *
+ * Two different questions, and membership alone cannot tell them apart. A rule
+ * that DROPPED the entry is doing its job — a CJS-first package names the
+ * `.d.cts` twin `dropParallelDeclarations` removes, and putting it back blind
+ * put it at the head of the truncated blob. A package naming a `src/index.ts`
+ * in `types` was never a surface-file candidate at all, and answering "has no
+ * .d.ts files" for it is not the same as answering without one file.
+ *
+ * The head matters on the uncached path, which prints this list into one
+ * truncated blob and nothing else.
+ */
+function entryFirst(selected, walked, pkg) {
+    if (pkg.entry === null)
+        return [...selected];
+    const kept = sameFile(selected, pkg.entry);
+    if (kept !== null)
+        return [kept, ...selected.filter(f => f !== kept)];
+    if (sameFile(walked, pkg.entry) !== null)
+        return [...selected];
+    return fs.existsSync(pkg.entry) ? [pkg.entry, ...selected] : [...selected];
 }
 function ingestBody(cache, pkg, profile, contentHash, supplements = []) {
     const ecosystem = profile.id;

package/dist/workers/eco-go.js

@@ -25,7 +25,7 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { ResolveError } from './docs-resolve.js';
 import { findAtOrAbove } from './eco-cargo.js';
-import { buildConstraint } from './go-surface.js';
+import { buildConstraint, codeOnly, splitGoItems } from './go-surface.js';
 import { readZip, readEntry, isUnsafeEntryName } from '../shared/zip.js';
 import { acquireStdlibPackage, findInGoroot, findSliced } from './go-stdlib.js';
 const PROXY = 'https://proxy.golang.org';
@@ -653,17 +653,27 @@ function holdsByDefault(src) {
 /**
  * The import paths a Go file's import block names.
  *
- * Scoped to the import declaration, not the file: a sibling's import path also
+ * Scoped to the import DECLARATION, not the file: a sibling's import path also
  * occurs as a plain string constant, in an error message and in a `go:generate`
  * line, and reading those keeps the very subpackage `selectOwnPackage` exists to
- * drop. An `ImportPath` is a `string_lit`, so the backtick form is legal Go and
+ * drop. A regex cannot draw that line — a column-0 `import (` also sits inside a
+ * generator template's raw string and inside a doc comment's example — so the
+ * split is the surface scanner's. That split strips only the comments BETWEEN
+ * declarations, and a commented-out import line inside the block is ordinary Go,
+ * so the item's own comments come off too.
+ * An `ImportPath` is a `string_lit`, so the backtick form is legal Go and
  * dropping it silently drops everything reachable only through it.
  */
 function importsOf(src) {
     const out = [];
-    for (const decl of src.matchAll(/^import\s*(?:\(([\s\S]*?)^\)|(.*))$/gm)) {
-        const body = decl[1] ?? decl[2] ?? '';
-        for (const m of body.matchAll(/"([^"\n]+)"|`([^`]+)`/g))
+    for (const item of splitGoItems(src)) {
+        if (/^package\b/.test(item.text))
+            continue;
+        // Go puts every import declaration before every other one, so the first
+        // item that is not an import ends the search.
+        if (!/^import\b/.test(item.text))
+            break;
+        for (const m of codeOnly(item.text).matchAll(/"([^"\n]+)"|`([^`]+)`/g))
             out.push(m[1] ?? m[2]);
     }
     return out;
@@ -683,9 +693,16 @@ function goMajor(name, version) {
     const inVersion = /^(?:v|go)?(\d+)\./.exec(version);
     return inVersion ? Number(inVersion[1]) : 1;
 }
-/** Does this file declare anything a caller of the package could be handed? */
+/**
+ * Does this file declare anything a caller of the package could be handed?
+ *
+ * Read from the scanned declarations, not the raw text. `cloud.google.com/go`'s
+ * doc.go is one block comment, and a wrapped sentence beginning `type ` sits at
+ * column 0 — enough for a multiline regex to call the root the API and drop the
+ * subdirectories that hold all of it.
+ */
 function declaresApi(src) {
-    return /^(?:func|type|var|const)\b/m.test(src);
+    return splitGoItems(src).some(item => /^(?:func|type|var|const)\b/.test(item.text));
 }
 /**
  * Keep the package the caller asked for, and only the subpackages it can reach.
@@ -729,7 +746,16 @@ export function selectOwnPackage(files, root, name, version) {
     const byDir = new Map();
     for (const f of files)
         byDir.set(dirOf(f), [...(byDir.get(dirOf(f)) ?? []), f]);
-    if (!(byDir.get('') ?? []).some(f => declaresApi(safeRead(f) ?? '')))
+    const sources = new Map();
+    const sourceOf = (f) => {
+        const seen = sources.get(f);
+        if (seen !== undefined)
+            return seen;
+        const text = safeRead(f) ?? '';
+        sources.set(f, text);
+        return text;
+    };
+    if (!(byDir.get('') ?? []).some(f => declaresApi(sourceOf(f))))
         return [...files];
     const major = goMajor(name, version);
     const reachable = new Set(['']);
@@ -737,7 +763,7 @@ export function selectOwnPackage(files, root, name, version) {
     while (queue.length > 0) {
         const dir = queue.shift();
         for (const f of byDir.get(dir) ?? []) {
-            for (const imp of importsOf(safeRead(f) ?? '')) {
+            for (const imp of importsOf(sourceOf(f))) {
                 if (!imp.startsWith(`${name}/`))
                     continue;
                 const sub = imp.slice(name.length + 1);
@@ -765,6 +791,7 @@ export function goContentFingerprintParts() {
         String(selectOwnPackage),
         String(declaresApi),
         String(goMajor),
-        String(importsOf)
+        String(importsOf),
+        String(codeOnly)
     ];
 }

package/dist/workers/go-surface.d.ts

@@ -38,6 +38,15 @@ export interface GoItem {
     pending: string;
     text: string;
 }
+/**
+ * A declaration's text with its comments removed and its literals intact.
+ *
+ * `splitGoItems` strips only what sits BETWEEN declarations. A comment inside an
+ * import block, or trailing one, stays in the item's own text, so a caller
+ * reading string literals out of a declaration reads the commented-out ones too
+ * — and a commented-out import is one of the commonest shapes in Go source.
+ */
+export declare function codeOnly(text: string): string;
 /**
  * Split source into declarations. Works unchanged on a struct body or a const
  * group, whose members obey the same semicolon rule with no keyword in front.

package/dist/workers/go-surface.js

@@ -162,6 +162,39 @@ function endsStatement(word, lastChar) {
         return !CONTINUING_KEYWORDS.has(word);
     return STMT_END_CHAR_RE.test(lastChar);
 }
+/**
+ * A declaration's text with its comments removed and its literals intact.
+ *
+ * `splitGoItems` strips only what sits BETWEEN declarations. A comment inside an
+ * import block, or trailing one, stays in the item's own text, so a caller
+ * reading string literals out of a declaration reads the commented-out ones too
+ * — and a commented-out import is one of the commonest shapes in Go source.
+ */
+export function codeOnly(text) {
+    let out = '';
+    let i = 0;
+    while (i < text.length) {
+        const c = text[i];
+        if (c === '/' && text[i + 1] === '/') {
+            const nl = text.indexOf('\n', i);
+            i = nl < 0 ? text.length : nl;
+        }
+        else if (c === '/' && text[i + 1] === '*') {
+            const close = text.indexOf('*/', i + 2);
+            i = close < 0 ? text.length : close + 2;
+        }
+        else if (c === '"' || c === "'" || c === '`') {
+            const end = skipLiteral(text, i);
+            out += text.slice(i, end);
+            i = end;
+        }
+        else {
+            out += c;
+            i++;
+        }
+    }
+    return out;
+}
 /**
  * Split source into declarations. Works unchanged on a struct body or a const
  * group, whose members obey the same semicolon rule with no keyword in front.
@@ -530,6 +563,7 @@ export function goContentFingerprint() {
         endsStatement,
         skipToCode,
         skipLiteral,
+        codeOnly,
         trailingGroup,
         splitBody,
         buildConstraint,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.40.31",
+    "version": "0.40.33",
     "description": "Deterministic task planning and spec-orchestration for local models — crash-safe /task pipelines with verify/enforce gates, a real-time remote web view, and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",