@mjasnikovs/pi-task 0.40.29 → 0.40.31

package/dist/workers/docs-core.js

@@ -3,7 +3,7 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { openCache as defaultOpenCache } from './docs-cache.js';
-import { ensureIndexed as defaultEnsureIndexed } from './docs-index.js';
+import { collectFiles, ensureIndexed as defaultEnsureIndexed } from './docs-index.js';
 import { npmProfile, chooseEcosystem, defaultEcosystemIo, ECOSYSTEMS } from './docs-ecosystems.js';
 import { resolvePackage as defaultResolvePackage, ResolveError, resolveTypeSource, typesPackageName, splitRuntimeNamespace } from './docs-resolve.js';
 import { retrieveChunks as defaultRetrieveChunks, PACKAGE_RETRIEVE_LIMIT, RETRIEVE_CONTENT_BUDGET } from './docs-retrieve.js';
@@ -549,7 +549,7 @@ function docsRawCached(cache, pkg, profile, query, ensureIndexed, retrieveChunks
 }
 function docsRawUncached(pkg, profile, cacheError, autoInstalled) {
     const parts = [];
-    const surfaceFiles = walkSurfaceAlpha(pkg.root, profile);
+    const surfaceFiles = collectFiles(pkg, profile).surface;
     const entryFirst = pkg.entry ? [pkg.entry, ...surfaceFiles.filter(f => f !== pkg.entry)] : surfaceFiles;
     for (const abs of entryFirst) {
         let raw;
@@ -596,30 +596,6 @@ function docsRawUncached(pkg, profile, cacheError, autoInstalled) {
         autoInstalled: autoInstalled ? true : undefined
     };
 }
-function walkSurfaceAlpha(root, profile) {
-    const out = [];
-    const stack = [root];
-    while (stack.length) {
-        const dir = stack.pop();
-        let entries;
-        try {
-            entries = fs.readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries) {
-            if (profile.skipDirs.includes(entry.name))
-                continue;
-            const full = path.join(dir, entry.name);
-            if (entry.isDirectory())
-                stack.push(full);
-            else if (entry.isFile() && profile.isSurfaceFile(entry.name))
-                out.push(full);
-        }
-    }
-    return out.sort();
-}
 function truncateHeadTail(s) {
     if (s.length <= NO_CACHE_TOTAL)
         return s;

package/dist/workers/docs-ecosystems.d.ts

@@ -140,7 +140,7 @@ export interface EcosystemProfile {
      * retrieval budget for text the reader already has, and neither is
      * separable downstream — same identifiers, same package, same version.
      */
-    selectFiles?: (files: readonly string[]) => string[];
+    selectFiles?: (files: readonly string[], pkg: ResolvedPackage) => string[];
     /** What this ecosystem's packages ship, for a "there is nothing to read" answer. */
     surfaceLabel: string;
     /**

package/dist/workers/docs-ecosystems.js

@@ -24,7 +24,7 @@ import { dropParallelDeclarations } from './docs-index.js';
 import { npmVersionLookup } from './npm-version.js';
 import { resolveCrate, cratesLatest, crateTarballUrl, crateOf, isValidCrateName, isRustFile, lockedVersion, rustSurface, cargoProjectName, childDirs, lockedDeps, manifestCrates, cargoExportGap, cargoContentFingerprint, cargoSupplementCandidates, CARGO_DECL_SPLIT_RE, CARGO_MEMBER_SPLIT_RE } from './eco-cargo.js';
 import { resolveHackage, hackageLatest, hackageVersion, hackageTarballUrl, hackageExtractDir, hackageProjectName, supplementCandidates, hackageExportGap, hackageContentFingerprint, findCabalTarball, cachedVersions, resolvedVersions, manifestPackages, isValidHackageName, isHaskellFile, haskellSurface, HACKAGE_DECL_SPLIT_RE, HACKAGE_SKIP_DIRS, HACKAGE_MEMBER_SPLIT_RE } from './eco-hackage.js';
-import { detectGo, isValidImportPath, resolveGoPackage, acquireGoModule, goDeclaredVersion, goLatest, goProjectName, goDeclaredDeps, goManifestDeps, isGoFile, selectBuildVariants, defaultGoModCache, goContentFingerprintParts } from './eco-go.js';
+import { detectGo, isValidImportPath, resolveGoPackage, acquireGoModule, goDeclaredVersion, goLatest, goProjectName, goDeclaredDeps, goManifestDeps, isGoFile, selectBuildVariants, selectOwnPackage, defaultGoModCache, goContentFingerprintParts } from './eco-go.js';
 import { goSurface, goContentFingerprint, GO_DECL_SPLIT_RE, GO_MEMBER_SPLIT_RE } from './go-surface.js';
 import { runChild } from '../shared/child-process.js';
 /**
@@ -503,7 +503,7 @@ const goProfile = {
     typeKeywords: ['type', 'struct', 'interface', 'func'],
     commentPrefix: '//',
     skipDirs: ['testdata', 'examples', 'vendor', 'internal', '.git'],
-    selectFiles: selectBuildVariants,
+    selectFiles: (files, pkg) => selectBuildVariants(selectOwnPackage(files, pkg.root, pkg.name, pkg.version)),
     surfaceLabel: '.go source or README',
     packageSubject: 'a Go package',
     projectGlobs: ['*.go'],

package/dist/workers/docs-index.d.ts

@@ -7,6 +7,10 @@ export interface IndexResult {
     chunksWritten: number;
     contentHash: string;
 }
+export interface CollectedFiles {
+    surface: string[];
+    readme: string | null;
+}
 /**
  * The gate that decides whether a package needs re-indexing.
  *
@@ -48,4 +52,13 @@ export declare function chunkerFingerprint(): string;
  * `.d.cts` still has to be readable, and all 123 of zod's had a `.d.ts` twin.
  */
 export declare function dropParallelDeclarations(files: readonly string[]): string[];
+/**
+ * The files that make up a package's surface, after every selection rule.
+ *
+ * Exported because the uncached fallback assembles the same package by hand: a
+ * walk that skipped these rules put a Go module's whole subtree, and both halves
+ * of every parallel `.d.cts`, into the one degraded path where the budget is a
+ * single truncated blob.
+ */
+export declare function collectFiles(pkg: ResolvedPackage, profile: EcosystemProfile): CollectedFiles;
 export declare function ensureIndexed(cache: CacheHandle, pkg: ResolvedPackage, profile?: EcosystemProfile, supplements?: readonly ResolvedPackage[]): IndexResult;

package/dist/workers/docs-index.js

@@ -177,11 +177,19 @@ function dropDeadMajors(files, root, version) {
     // own version is not shipping a dead major — it is shipping its API there.
     return kept.length > 0 ? kept : files;
 }
-function collectFiles(pkg, profile) {
+/**
+ * The files that make up a package's surface, after every selection rule.
+ *
+ * Exported because the uncached fallback assembles the same package by hand: a
+ * walk that skipped these rules put a Go module's whole subtree, and both halves
+ * of every parallel `.d.cts`, into the one degraded path where the budget is a
+ * single truncated blob.
+ */
+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) : surface,
+        surface: profile.selectFiles ? profile.selectFiles(surface, pkg) : surface,
         readme: pkg.readme
     };
 }

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

@@ -174,6 +174,40 @@ export declare function acquireGoModule(importPath: string, pinned: string | nul
  * with no tags: a bare negation holds, a bare tag does not.
  */
 export declare function selectBuildVariants(files: readonly string[]): string[];
+/**
+ * Keep the package the caller asked for, and only the subpackages it can reach.
+ *
+ * A Go subdirectory is a DIFFERENT importable package — `zapcore` is not reachable
+ * as `zap.X` and `ginS` is not `gin` — so walking a module's whole tree files every
+ * one of them under the parent's name and its version banner. Measured on re-run 9's
+ * cache: 71% of `encoding/json`'s chunks, 54% of zap's and 34% of gin's belonged to
+ * a package nobody asked about, and it reached retrieval — a question about
+ * registering a gin route came back with 10 `ginS` chunks of 51, in a corpus already
+ * spending 19,941 of its 24,000 bytes.
+ *
+ * The gate is the ROOT'S OWN IMPORTS, closed over: zap's `Field` is
+ * `= zapcore.Field`, so dropping `zapcore` would break the alias hop that defect 3
+ * exists to serve, and zapcore in turn reaches `buffer`. What that keeps is what a
+ * caller of this package can actually be handed; `zapgrpc`, `zaptest`, `ginS`,
+ * `httputil` and `net/http/pprof` are reachable only by importing them directly,
+ * which the tool already resolves on its own — `github.com/gin-gonic/gin/binding`
+ * asked for by path reads 0% foreign.
+ *
+ * A mismatching top-level `vN/` goes whatever the imports say. `encoding/json` is
+ * built ON `encoding/json/v2` and imports it, but v2 is a different major of the
+ * same API with the same identifiers — `Marshal`, `Unmarshal` — and half the
+ * retrieval for the commonest decode question came back from it under a
+ * `Per encoding/json@go1.25.14` header. That is `dropDeadMajors`' case, which
+ * cannot fire here because it reads the major with `/^(\d+)\./` and Go spells its
+ * versions `v1.12.0` and `go1.25.14`.
+ *
+ * A root that declares nothing is not the API — the aws-sdk shape holds no Go files
+ * at all, and `cloud.google.com/go` holds a `doc.go` with a package clause and no
+ * imports while its whole surface lives in subdirectories. Either keeps everything,
+ * for the same reason `dropDeadMajors` keeps a package whose whole surface lives
+ * under one `vN/`.
+ */
+export declare function selectOwnPackage(files: readonly string[], root: string, name: string, version: string): string[];
 /**
  * Everything below `goSurface` and the file-selection rule that feeds it, by
  * source, so a fix to either re-indexes rather than being masked by a cache hit.

package/dist/workers/eco-go.js

@@ -650,10 +650,121 @@ function holdsByDefault(src) {
         return true;
     return expr.split(/\s*&&\s*/).every(term => term.startsWith('!'));
 }
+/**
+ * The import paths a Go file's import block names.
+ *
+ * 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
+ * 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))
+            out.push(m[1] ?? m[2]);
+    }
+    return out;
+}
+/**
+ * The package's own major, as Go spells it.
+ *
+ * v2 and up put the major in the module PATH, and the version agrees with it, so
+ * either reads the same answer. The standard library has neither and is 1: it is
+ * `go1.25.14`, and `encoding/json/v2` is a separate experimental package rather
+ * than a newer major of this one.
+ */
+function goMajor(name, version) {
+    const inPath = /\/v(\d+)$/.exec(name);
+    if (inPath)
+        return Number(inPath[1]);
+    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? */
+function declaresApi(src) {
+    return /^(?:func|type|var|const)\b/m.test(src);
+}
+/**
+ * Keep the package the caller asked for, and only the subpackages it can reach.
+ *
+ * A Go subdirectory is a DIFFERENT importable package — `zapcore` is not reachable
+ * as `zap.X` and `ginS` is not `gin` — so walking a module's whole tree files every
+ * one of them under the parent's name and its version banner. Measured on re-run 9's
+ * cache: 71% of `encoding/json`'s chunks, 54% of zap's and 34% of gin's belonged to
+ * a package nobody asked about, and it reached retrieval — a question about
+ * registering a gin route came back with 10 `ginS` chunks of 51, in a corpus already
+ * spending 19,941 of its 24,000 bytes.
+ *
+ * The gate is the ROOT'S OWN IMPORTS, closed over: zap's `Field` is
+ * `= zapcore.Field`, so dropping `zapcore` would break the alias hop that defect 3
+ * exists to serve, and zapcore in turn reaches `buffer`. What that keeps is what a
+ * caller of this package can actually be handed; `zapgrpc`, `zaptest`, `ginS`,
+ * `httputil` and `net/http/pprof` are reachable only by importing them directly,
+ * which the tool already resolves on its own — `github.com/gin-gonic/gin/binding`
+ * asked for by path reads 0% foreign.
+ *
+ * A mismatching top-level `vN/` goes whatever the imports say. `encoding/json` is
+ * built ON `encoding/json/v2` and imports it, but v2 is a different major of the
+ * same API with the same identifiers — `Marshal`, `Unmarshal` — and half the
+ * retrieval for the commonest decode question came back from it under a
+ * `Per encoding/json@go1.25.14` header. That is `dropDeadMajors`' case, which
+ * cannot fire here because it reads the major with `/^(\d+)\./` and Go spells its
+ * versions `v1.12.0` and `go1.25.14`.
+ *
+ * A root that declares nothing is not the API — the aws-sdk shape holds no Go files
+ * at all, and `cloud.google.com/go` holds a `doc.go` with a package clause and no
+ * imports while its whole surface lives in subdirectories. Either keeps everything,
+ * for the same reason `dropDeadMajors` keeps a package whose whole surface lives
+ * under one `vN/`.
+ */
+export function selectOwnPackage(files, root, name, version) {
+    const rel = (f) => path.relative(root, f).replace(/\\/g, '/');
+    const dirOf = (f) => {
+        const parts = rel(f).split('/');
+        return parts.slice(0, -1).join('/');
+    };
+    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) ?? '')))
+        return [...files];
+    const major = goMajor(name, version);
+    const reachable = new Set(['']);
+    const queue = [''];
+    while (queue.length > 0) {
+        const dir = queue.shift();
+        for (const f of byDir.get(dir) ?? []) {
+            for (const imp of importsOf(safeRead(f) ?? '')) {
+                if (!imp.startsWith(`${name}/`))
+                    continue;
+                const sub = imp.slice(name.length + 1);
+                const top = /^v(\d+)$/.exec(sub.split('/')[0]);
+                if (top && Number(top[1]) !== major)
+                    continue;
+                if (reachable.has(sub) || !byDir.has(sub))
+                    continue;
+                reachable.add(sub);
+                queue.push(sub);
+            }
+        }
+    }
+    return files.filter(f => reachable.has(dirOf(f)));
+}
 /**
  * Everything below `goSurface` and the file-selection rule that feeds it, by
  * source, so a fix to either re-indexes rather than being masked by a cache hit.
  */
 export function goContentFingerprintParts() {
-    return [String(selectBuildVariants), String(holdsByDefault), String(isWantedEntry)];
+    return [
+        String(selectBuildVariants),
+        String(holdsByDefault),
+        String(isWantedEntry),
+        String(selectOwnPackage),
+        String(declaresApi),
+        String(goMajor),
+        String(importsOf)
+    ];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.40.29",
+    "version": "0.40.31",
     "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",