@ilya-lesikov/pi-pi 0.10.0 → 0.11.0

package/3p/pi-subagents/package.json

@@ -13,7 +13,6 @@
     "url": "https://github.com/tintinweb/pi-subagents/issues"
   },
   "keywords": [
-    "pi-package",
     "pi",
     "pi-extension",
     "subagent",

package/extensions/orchestrator/flant-infra.more.test.ts

@@ -235,6 +235,61 @@ describe("updateFlantInfra", () => {
     expect([...pi.registered.keys()].sort()).toEqual(["pp-flant-anthropic", "pp-flant-openai"]);
   });
 
+  it("serves a fresh cache without re-fetching by default", async () => {
+    const dir = makeTempDir();
+    const cacheDir = join(dir, "extensions", "pp", "cache");
+    mkdirSync(cacheDir, { recursive: true });
+    writeFileSync(
+      join(cacheDir, "flant-models.json"),
+      JSON.stringify({
+        enabled: true,
+        cacheTTLDays: 7,
+        lastUpdated: new Date().toISOString(),
+        cachedFlantModels: ["claude-opus-4-8"],
+        cachedOpenRouterData: {},
+      }),
+      "utf-8",
+    );
+    process.env.FLANT_API_KEY = "flant-k";
+    const mod = await loadModule(dir);
+    const fetchFn = stubFetch(() => { throw new Error("should not fetch"); });
+    const res = await mod.updateFlantInfra(makePi());
+    expect(res.ok).toBe(true);
+    expect(res.models).toEqual(["claude-opus-4-8"]);
+    expect(fetchFn).not.toHaveBeenCalled();
+  });
+
+  it("force bypasses a fresh cache and re-fetches the model list", async () => {
+    const dir = makeTempDir();
+    const cacheDir = join(dir, "extensions", "pp", "cache");
+    mkdirSync(cacheDir, { recursive: true });
+    writeFileSync(
+      join(cacheDir, "flant-models.json"),
+      JSON.stringify({
+        enabled: true,
+        cacheTTLDays: 7,
+        lastUpdated: new Date().toISOString(),
+        cachedFlantModels: ["claude-opus-4-8"],
+        cachedOpenRouterData: {},
+      }),
+      "utf-8",
+    );
+    process.env.FLANT_API_KEY = "flant-k";
+    const mod = await loadModule(dir);
+    stubFetch((url: string) => {
+      if (url.includes("llm-api.flant.ru/v1/models")) {
+        return { ok: true, status: 200, json: async () => ({ data: [{ id: "sub/claude-fable-5" }, { id: "claude-fable-5" }] }) };
+      }
+      if (url.includes("openrouter.ai")) {
+        return { ok: true, status: 200, json: async () => ({ data: [] }) };
+      }
+      throw new Error(`unexpected ${url}`);
+    });
+    const res = await mod.updateFlantInfra(makePi(), { force: true });
+    expect(res.ok).toBe(true);
+    expect(res.models).toContain("sub/claude-fable-5");
+  });
+
   it("falls back to cached models when discovery throws", async () => {
     const dir = makeTempDir();
     const cacheDir = join(dir, "extensions", "pp", "cache");

package/extensions/orchestrator/flant-infra.ts

@@ -606,10 +606,10 @@ export function registerFlantProviders(
   const subscription = options.subscription ?? loadFlantSettings().subscription;
   let subModels: string[] = [];
   if (subscription) {
-    // The gateway only defines `sub/` model groups for a subset of claude
-    // models (e.g. no sub/claude-fable-5) — registering unconfirmed ones
-    // yields "Invalid model name" 400s. Model lists cached before the gateway
-    // exposed `sub/…` ids have none; fall back to all claude models then.
+    // The gateway defines `sub/` model groups for only some claude models —
+    // registering unconfirmed ones yields "Invalid model name" 400s. Model
+    // lists cached before the gateway exposed `sub/…` ids have none; fall back
+    // to all claude models then.
     const subEligible = subConfirmed.size > 0
       ? anthropicModels.filter((m) => subConfirmed.has(m))
       : anthropicModels;
@@ -899,8 +899,18 @@ export function getFlantGeneratedConfig(): Partial<PiPiConfig> | null {
 
 (globalThis as any)[Symbol.for("pi-pi:flant-config")] = getFlantGeneratedConfig;
 
+export interface UpdateFlantOptions {
+  /**
+   * Bypass the TTL cache and re-fetch the model list from the gateway even when
+   * the cache is still fresh. Set by the explicit "Update now" action so it does
+   * what its label promises; auto/startup callers omit it and stay cache-bound.
+   */
+  force?: boolean;
+}
+
 export async function updateFlantInfra(
   pi: ExtensionAPI,
+  options: UpdateFlantOptions = {},
 ): Promise<{ ok: boolean; error?: string; models?: string[] }> {
   setPI(pi);
   const settings = loadFlantSettings();
@@ -911,8 +921,9 @@ export async function updateFlantInfra(
     await refreshClaudeOAuthToken();
   }
 
-  let models = isCacheValid(settings) ? settings.cachedFlantModels : null;
-  let metadata = isCacheValid(settings) ? settings.cachedOpenRouterData : null;
+  const cacheOk = !options.force && isCacheValid(settings);
+  let models = cacheOk ? settings.cachedFlantModels : null;
+  let metadata = cacheOk ? settings.cachedOpenRouterData : null;
   let refreshed = false;
 
   if (!models || !metadata) {

package/extensions/orchestrator/pp-menu.ts

@@ -1094,7 +1094,7 @@ async function showFlantInfraMenu(orchestrator: Orchestrator, ctx: any): Promise
     }
 
     if (choice === "Update now") {
-      const result = await updateFlantInfra(orchestrator.pi);
+      const result = await updateFlantInfra(orchestrator.pi, { force: true });
       const message = describeUpdateResult(result);
       ctx.ui.notify(message.text, message.kind);
       continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ilya-lesikov/pi-pi",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Pi-Pi Coding Agent: based on Pi Coding Agent, but twice as good",
   "keywords": [
     "pi-package",
@@ -37,7 +37,8 @@
     "test": "vitest run --exclude '3p/**'",
     "test:watch": "vitest --exclude '3p/**'",
     "test:3p": "bash scripts/test-3p.sh",
-    "test:all": "vitest run --exclude '3p/**' && bash scripts/test-3p.sh",
+    "test:package": "bash scripts/test-package.sh",
+    "test:all": "vitest run --exclude '3p/**' && bash scripts/test-3p.sh && bash scripts/test-package.sh",
     "coverage": "vitest run --exclude '3p/**' --coverage"
   },
   "pi": {
@@ -53,8 +54,10 @@
   "dependencies": {
     "@joplin/turndown-plugin-gfm": "^1.0.64",
     "@pierre/diffs": "^1.2.0",
+    "croner": "^10.0.1",
     "effect": "^3.0.0",
     "minimatch": "^10.0.0",
+    "nanoid": "^5.0.0",
     "pino": "^10.3.1",
     "proper-lockfile": "^4.1.2",
     "turndown": "^7.2.0",

package/scripts/lib/smoke-resolve.mjs

@@ -0,0 +1,99 @@
+// Runs from INSIDE the installed package directory (import.meta.url is under the package), so
+// dynamic import() of a bare specifier resolves through the installed artifact's own
+// node_modules chain — the same resolution pi performs at extension load. Exits non-zero if a
+// registered extension path is missing or a required runtime specifier fails to load.
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PKG_DIR = dirname(fileURLToPath(import.meta.url));
+
+function fail(msg) {
+  console.error(`  ✗ ${msg}`);
+  process.exitCode = 1;
+}
+
+const pkg = JSON.parse(readFileSync(join(PKG_DIR, "package.json"), "utf8"));
+
+const extEntries = pkg?.pi?.extensions ?? [];
+if (extEntries.length === 0) fail("package.json has no pi.extensions entries");
+for (const entry of extEntries) {
+  if (existsSync(resolve(PKG_DIR, entry))) {
+    console.log(`  ✓ extension present: ${entry}`);
+  } else {
+    fail(`registered extension path missing from artifact: ${entry}`);
+  }
+}
+
+// Bare specifiers pi itself supplies to loaded extensions — never mirrored into dependencies.
+const peerSupplied = new Set(Object.keys(pkg.peerDependencies ?? {}));
+
+function isBuiltin(spec) {
+  return spec.startsWith("node:");
+}
+function isRelative(spec) {
+  return spec.startsWith(".") || spec.startsWith("/");
+}
+function packageName(spec) {
+  const parts = spec.split("/");
+  return spec.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+
+function collectTsFiles(dir) {
+  const out = [];
+  for (const name of readdirSync(dir)) {
+    const full = join(dir, name);
+    const st = statSync(full);
+    if (st.isDirectory()) out.push(...collectTsFiles(full));
+    else if (name.endsWith(".ts")) out.push(full);
+  }
+  return out;
+}
+
+// Scope the scan to the pi-subagents source only. Other shipped 3p sources reference SDK
+// specifiers behind lazy `await import()` guards that are intentionally NOT root dependencies;
+// scanning them would produce a permanently failing test.
+const SCAN_DIR = join(PKG_DIR, "3p", "pi-subagents", "src");
+if (!existsSync(SCAN_DIR)) {
+  fail(`expected shipped source dir missing: 3p/pi-subagents/src`);
+  process.exit(process.exitCode ?? 1);
+}
+
+// Value (non-type) import/export ... from "spec" and dynamic import("spec"). `import type` /
+// `export type` statements are type-only and erased at build, so they carry no runtime requirement.
+const FROM_RE = /(^|\n)\s*(import|export)\s+(?!type\b)(?:[^;]*?\sfrom\s+)?["']([^"']+)["']/g;
+const DYN_RE = /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g;
+
+const required = new Set();
+for (const file of collectTsFiles(SCAN_DIR)) {
+  const src = readFileSync(file, "utf8");
+  for (const m of src.matchAll(FROM_RE)) addSpec(m[3]);
+  for (const m of src.matchAll(DYN_RE)) addSpec(m[1]);
+}
+function addSpec(spec) {
+  if (isBuiltin(spec) || isRelative(spec)) return;
+  const name = packageName(spec);
+  if (peerSupplied.has(name)) return;
+  required.add(name);
+}
+
+// Floor: these two are the runtime imports that broke consumer installs; assert them explicitly
+// even if the extractor's shape ever changes.
+required.add("croner");
+required.add("nanoid");
+
+const specs = [...required].sort();
+console.log(`  runtime specifiers to resolve: ${specs.join(", ")}`);
+
+for (const spec of specs) {
+  try {
+    await import(spec);
+    console.log(`  ✓ resolved: ${spec}`);
+  } catch (err) {
+    fail(`cannot resolve '${spec}' from installed package: ${err?.message ?? err}`);
+  }
+}
+
+if (process.exitCode) {
+  console.error("  → the root package is missing a runtime dependency its shipped extensions need.");
+}

package/scripts/test-package.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+# Release-layout smoke test: pack the root package, install the tarball into a throwaway
+# directory OUTSIDE this checkout, and verify the shipped extension artifact resolves its
+# runtime imports from the installed tree alone.
+#
+# Why this exists: the root `npm test` excludes 3p/** and the vendored suites run inside
+# 3p/*/node_modules, so a bare import that a vendored extension needs but the root package
+# forgets to declare is invisible in the dev checkout (its node_modules still has the package).
+# It only surfaces after a clean `npm install` by a consumer — exactly the croner/nanoid
+# regression this guards against. Resolving bare specifiers from the installed package tree is
+# the only shape that reproduces that failure.
+#
+# Registry access is required (npm install of the tarball fetches deps, runs the root
+# postinstall, and npm v7+ auto-installs peerDependencies). Offline CI: warm the npm cache and
+# export a --prefer-offline-friendly registry mirror.
+set -uo pipefail
+cd "$(dirname "$0")/.."
+ROOT="$(pwd)"
+
+TMPDIR_SMOKE="$(mktemp -d)"
+trap 'rm -rf "$TMPDIR_SMOKE"' EXIT
+
+echo "▶ packing root package"
+PACK_JSON="$(npm pack --json --pack-destination "$TMPDIR_SMOKE" 2>/dev/null)"
+TARBALL="$(node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{const a=JSON.parse(s);process.stdout.write(a[0].filename)})' <<<"$PACK_JSON")"
+if [ -z "$TARBALL" ] || [ ! -f "$TMPDIR_SMOKE/$TARBALL" ]; then
+  echo "ERROR: npm pack did not produce a tarball (got: '$TARBALL')." >&2
+  exit 1
+fi
+echo "  tarball: $TARBALL"
+
+INSTALL_DIR="$TMPDIR_SMOKE/install"
+mkdir -p "$INSTALL_DIR"
+( cd "$INSTALL_DIR" && npm init -y >/dev/null 2>&1 )
+
+echo "▶ installing tarball into a clean consumer directory"
+if ! ( cd "$INSTALL_DIR" && npm install "$TMPDIR_SMOKE/$TARBALL" --no-audit --no-fund 2>&1 ); then
+  echo "ERROR: installing the packed tarball failed." >&2
+  exit 1
+fi
+
+PKG_NAME="$(node -e 'process.stdout.write(require("./package.json").name)')"
+PKG_DIR="$INSTALL_DIR/node_modules/$PKG_NAME"
+if [ ! -d "$PKG_DIR" ]; then
+  echo "ERROR: installed package not found at $PKG_DIR" >&2
+  exit 1
+fi
+
+# Run the resolution check from a helper placed INSIDE the installed package, so bare-specifier
+# resolution provably walks the artifact's own node_modules hierarchy (not this checkout's).
+CHECK="$PKG_DIR/__smoke-resolve.mjs"
+cp "$ROOT/scripts/lib/smoke-resolve.mjs" "$CHECK"
+
+echo "▶ resolving shipped extension runtime imports from the install tree"
+( cd "$PKG_DIR" && node "$CHECK" )
+STATUS=$?
+
+if [ $STATUS -ne 0 ]; then
+  echo "✗ package smoke test FAILED" >&2
+  exit $STATUS
+fi
+echo "✓ package smoke test passed"