@vimhead.dev/pi-norn 0.1.0-tip.36148588553.1 → 0.1.0-tip.36679386408.1

package/README.md

@@ -10,9 +10,13 @@ pi install npm:@vimhead.dev/pi-norn@tip
 pi
 ```
 
-The adapter selects `norn` from `PATH`, or `pi --norn-executable /absolute/path/to/norn`.
+Use [project-local runtime selection](https://github.com/vimhead/norn#project-local-runtime-selection)
+with `.nornrc.json` to launch an installed CLI dependency without global Norn.
+`pi --norn-executable /absolute/path/to/norn` overrides project selection;
+without either, the adapter selects `norn` from `PATH`.
 It does not carry another Norn runtime or SDK and does not inject authoring context
-into Norn-managed agent sessions. Workflow discovery is skipped in untrusted
-projects. Both introductions refresh at session start or `/reload`.
+into Norn-managed agent sessions. Repository runtime configuration and workflow
+discovery are skipped in untrusted projects. Both introductions refresh at session
+start or `/reload`.
 
 [Runtime installation](https://github.com/vimhead/norn#installation).

package/dist/index.js

@@ -1,6 +1,121 @@
 // ../core/src/agent-protocol.ts
 var AGENT_RESPONSE_TOOL_NAME = "pi_workflows_agent_response";
 
+// ../core/src/runtime-resolution.mjs
+import { lstat, readFile, realpath, stat } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
+var CLI_PACKAGE_NAME = "@vimhead.dev/norn-cli";
+var RuntimeResolutionError = class extends Error {
+};
+async function resolveNornRuntime({
+  cwd,
+  executableOverride,
+  isProjectTrusted,
+  nodeExecutable
+}) {
+  if (executableOverride !== null) {
+    if (typeof executableOverride !== "string" || !executableOverride.trim())
+      throw new RuntimeResolutionError(
+        "Norn executable override must be a nonempty executable path or name."
+      );
+    return { executable: executableOverride, args: [] };
+  }
+  if (!isProjectTrusted) return { executable: "norn", args: [] };
+  const configPath = await findAncestorEntry({
+    cwd,
+    relativePath: ".nornrc.json"
+  });
+  if (configPath === null) return { executable: "norn", args: [] };
+  const packageRoot = await readRuntimePackageRoot(configPath);
+  const scriptPath = await resolvePackageEntrypoint(packageRoot);
+  return { executable: nodeExecutable, args: [scriptPath] };
+}
+async function readRuntimePackageRoot(configPath) {
+  const configuration = await readManifest(configPath);
+  if (!isRecord(configuration) || Object.keys(configuration).some((key) => key !== "runtime") || !isRecord(configuration.runtime) || Object.keys(configuration.runtime).some((key) => key !== "packageRoot") || typeof configuration.runtime.packageRoot !== "string" || !configuration.runtime.packageRoot.trim())
+    throw new RuntimeResolutionError(
+      `Invalid ${JSON.stringify(configPath)}: expected { "runtime": { "packageRoot": "./path/to/package" } }.`
+    );
+  return resolve(dirname(configPath), configuration.runtime.packageRoot);
+}
+async function resolvePackageEntrypoint(packageRoot) {
+  const owner = await readManifest(join(packageRoot, "package.json"));
+  if (!isRecord(owner) || ![
+    owner.dependencies,
+    owner.devDependencies,
+    owner.optionalDependencies
+  ].some(
+    (dependencies) => isRecord(dependencies) && typeof dependencies[CLI_PACKAGE_NAME] === "string"
+  ))
+    throw new RuntimeResolutionError(
+      `The package at ${JSON.stringify(packageRoot)} must declare ${CLI_PACKAGE_NAME} as a dependency or devDependency.`
+    );
+  const packagePath = await findAncestorEntry({
+    cwd: packageRoot,
+    relativePath: `node_modules/${CLI_PACKAGE_NAME}`
+  });
+  if (packagePath === null)
+    throw new RuntimeResolutionError(
+      `Cannot find ${CLI_PACKAGE_NAME} from ${JSON.stringify(packageRoot)}. Install that package's dependencies and retry.`
+    );
+  const manifestPath = join(packagePath, "package.json");
+  const installedManifestPath = await realpath(manifestPath).catch(() => {
+    throw new RuntimeResolutionError(
+      `Cannot resolve the installed CLI at ${JSON.stringify(manifestPath)}. Reinstall the selected package's dependencies.`
+    );
+  });
+  const installed = await readManifest(installedManifestPath);
+  const entrypoint = isRecord(installed?.bin) ? installed.bin.norn : void 0;
+  if (installed?.name !== CLI_PACKAGE_NAME || typeof entrypoint !== "string" || !entrypoint.trim() || isAbsolute(entrypoint))
+    throw new RuntimeResolutionError(
+      `Invalid Norn CLI manifest at ${JSON.stringify(installedManifestPath)}: expected a relative bin.norn entrypoint.`
+    );
+  const installationRoot = dirname(installedManifestPath);
+  const scriptPath = resolve(installationRoot, entrypoint);
+  if (!scriptPath.startsWith(`${installationRoot}${sep}`))
+    throw new RuntimeResolutionError(
+      `Norn CLI entrypoint must be inside ${JSON.stringify(installationRoot)}.`
+    );
+  try {
+    if (!(await stat(scriptPath)).isFile()) throw new Error();
+  } catch {
+    throw new RuntimeResolutionError(
+      `Missing Norn CLI entrypoint at ${JSON.stringify(scriptPath)}. Reinstall the selected package's dependencies.`
+    );
+  }
+  return scriptPath;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+async function readManifest(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    throw new RuntimeResolutionError(
+      `Cannot read valid JSON from ${JSON.stringify(path)}. Check the selected package and configuration.`
+    );
+  }
+}
+async function findAncestorEntry({ cwd, relativePath }) {
+  let directory = resolve(cwd);
+  while (true) {
+    const candidate = join(directory, relativePath);
+    try {
+      await lstat(candidate);
+      return candidate;
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw new RuntimeResolutionError(
+          `Cannot inspect ${JSON.stringify(candidate)}.`
+        );
+    }
+    const parent = dirname(directory);
+    if (parent === directory) return null;
+    directory = parent;
+  }
+}
+
 // src/index.ts
 var INTRO_START = "<norn-docs-intro>";
 var INTRO_END = "</norn-docs-intro>";
@@ -8,7 +123,7 @@ function nornPiAdapter(pi) {
   let cachedIntro;
   pi.registerFlag("norn-executable", {
     type: "string",
-    description: "Norn executable for docs intro and workflows intro (defaults to norn on PATH). Accepts an executable path, not a shell command."
+    description: "Norn executable override for docs intro and workflows intro (otherwise uses trusted .nornrc.json, then norn on PATH). Accepts an executable path, not a shell command."
   });
   pi.on("session_start", async (_event, ctx) => {
     cachedIntro = void 0;
@@ -18,20 +133,32 @@ function nornPiAdapter(pi) {
       const configuredExecutable = pi.getFlag("norn-executable");
       if (configuredExecutable !== void 0 && typeof configuredExecutable !== "string")
         throw new Error("Invalid Norn executable flag");
-      const executable = configuredExecutable ?? "norn";
+      const isProjectTrusted = ctx.isProjectTrusted();
+      const invocation = await resolveNornRuntime({
+        cwd: ctx.cwd,
+        executableOverride: configuredExecutable ?? null,
+        isProjectTrusted,
+        nodeExecutable: process.versions.bun ? "node" : process.execPath
+      });
       const [intro, workflowsIntro] = await Promise.all([
-        loadIntroduction({ pi, executable, cwd: ctx.cwd, group: "docs" }),
-        ctx.isProjectTrusted() ? loadIntroduction({
+        loadIntroduction({ pi, invocation, cwd: ctx.cwd, group: "docs" }),
+        isProjectTrusted ? loadIntroduction({
           pi,
-          executable,
+          invocation,
           cwd: ctx.cwd,
           group: "workflows"
         }) : Promise.resolve("")
       ]);
-      cachedIntro = { executable, intro, workflowsIntro };
-    } catch {
+      cachedIntro = {
+        configuredExecutable,
+        cwd: ctx.cwd,
+        isProjectTrusted,
+        intro,
+        workflowsIntro
+      };
+    } catch (error) {
       ctx.ui.notify(
-        "Norn introduction unavailable. Check --norn-executable and run that executable with 'docs intro' and 'workflows intro' in the project directory to diagnose, then /reload to retry.",
+        `Norn introduction unavailable.${error instanceof RuntimeResolutionError ? ` ${error.message}` : ""} Check --norn-executable or .nornrc.json and run the selected runtime with 'docs intro' and 'workflows intro' in the project directory to diagnose, then /reload to retry.`,
         "warning"
       );
     }
@@ -41,10 +168,10 @@ function nornPiAdapter(pi) {
     if (pi.getAllTools().some((tool) => tool.name === AGENT_RESPONSE_TOOL_NAME))
       return;
     if (event.systemPrompt.includes(INTRO_START)) return;
-    if (cachedIntro.executable !== (pi.getFlag("norn-executable") ?? "norn")) {
+    if (cachedIntro.configuredExecutable !== pi.getFlag("norn-executable") || cachedIntro.cwd !== ctx.cwd || cachedIntro.isProjectTrusted !== ctx.isProjectTrusted()) {
       cachedIntro = void 0;
       ctx.ui.notify(
-        "Norn executable changed. Run /reload to refresh its introduction.",
+        "Norn runtime selection or project trust changed. Run /reload to refresh its introduction.",
         "warning"
       );
       return;
@@ -61,10 +188,11 @@ ${cachedIntro.workflowsIntro}` : ""}`
   });
 }
 async function loadIntroduction(input) {
-  const result = await input.pi.exec(input.executable, [input.group, "intro"], {
-    cwd: input.cwd,
-    timeout: 1e4
-  });
+  const result = await input.pi.exec(
+    input.invocation.executable,
+    [...input.invocation.args, input.group, "intro"],
+    { cwd: input.cwd, timeout: 1e4 }
+  );
   if (result.killed || result.code !== 0)
     throw new Error(`Norn ${input.group} intro did not complete successfully`);
   const response = JSON.parse(result.stdout);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vimhead.dev/pi-norn",
-  "version": "0.1.0-tip.36148588553.1",
+  "version": "0.1.0-tip.36679386408.1",
   "description": "Deliver installed Norn runtime documentation to outer Pi agent sessions.",
   "type": "module",
   "license": "MIT",
@@ -38,7 +38,7 @@
     }
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.85.1",
+    "@earendil-works/pi-coding-agent": "0.99.1",
     "@vimhead.dev/norn-core": "0.0.0"
   },
   "scripts": {