@mjasnikovs/pi-task 0.40.32 → 0.40.33

package/dist/workers/docs-core.js

@@ -549,13 +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;
-    // Only an entry the rules KEPT goes first. A CJS-first package names its
-    // `.d.cts` in `types`, so the entry is exactly the twin `collectFiles` drops,
-    // and prepending it blind put it back at the head of the truncated blob.
-    const entry = pkg.entry !== null && surfaceFiles.includes(pkg.entry) ? pkg.entry : null;
-    const entryFirst = entry === null ? surfaceFiles : [entry, ...surfaceFiles.filter(f => f !== entry)];
-    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,7 +96,9 @@ 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.
@@ -119,17 +126,19 @@ function walkSurface(root, profile) {
                 catch {
                     continue;
                 }
-                const relReal = path.relative(root, realPath);
-                if (relReal.startsWith('..'))
+                if (!withinPackage(root, realPath, profile))
                     continue;
                 if (stat.isDirectory()) {
                     if (walked.has(realPath))
                         continue;
                     walked.add(realPath);
                     stack.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(realPath))
-                    out.push(realPath);
+                else if (stat.isFile() && profile.isSurfaceFile(entry.name))
+                    out.add(realPath);
                 continue;
             }
             if (entry.isDirectory()) {
@@ -139,10 +148,23 @@ function walkSurface(root, profile) {
                 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.
@@ -200,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, splitGoItems } 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';
@@ -658,16 +658,22 @@ function holdsByDefault(src) {
  * line, and reading those keeps the very subpackage `selectOwnPackage` exists to
  * 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, which already skips comments and literals.
+ * 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 item of splitGoItems(src)) {
-        if (!/^import\b/.test(item.text))
+        if (/^package\b/.test(item.text))
             continue;
-        for (const m of item.text.matchAll(/"([^"\n]+)"|`([^`]+)`/g))
+        // 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;
@@ -785,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.32",
+    "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",