@magnitudedev/pi-extension 0.0.1 → 0.0.3-alpha.0

package/README.md

@@ -1,95 +1,63 @@
 # Magnitude for Pi
 
-This Pi package adds Magnitude model management commands and live local-inference progress to Pi's
-built-in working row above the editor.
+Run Pi on local models. Free, private, and offline.
 
-Requires Pi 0.83.0 or newer. Install from your terminal:
+Magnitude runs the best local models for your hardware, plugged into the agent you already use.
+It profiles your machine, recommends the models that fit, then downloads, tunes, and runs them.
 
-```sh
-pi install npm:@magnitudedev/pi-extension
-```
+## Get started
 
-On the next fresh interactive Pi launch, Magnitude asks **“Set up local models with Magnitude now?”**
-Yes opens Magnitude's actual graphical setup in the same terminal, including its model rankings,
-radar, downloads, and loading progress. It connects Pi automatically at the final step, then returns
-to the same Pi conversation with the selected model active. No agent prompt or cloud credentials
-are needed. If Magnitude is missing, accepting setup installs the CLI with
-`npm install --global @magnitudedev/cli` before opening onboarding. Pi stays visible with its native
-spinner: “Installing Magnitude…”. Installer output is suppressed; failures
-show a concise diagnostic. Escape cancels preparation, and `/magnitude-setup` retries.
-An existing CLI is preserved. The extension invokes `magnitude setup --host pi`; `--host` is hidden from help.
-If an older CLI does not recognize that option, update it explicitly and retry; it is never silently
-replaced.
-
-No or Escape leaves “You can set up local models anytime with `/magnitude-setup`.” in the conversation.
-The offer is remembered per Pi profile across restarts, reloads, and package updates. Existing
-Magnitude model configurations, non-interactive modes, conversations, and startup prompts are left
-alone. Run `/magnitude-setup` whenever you want to start onboarding yourself.
-
-The package includes the Magnitude usage skill; an already-loaded skill of that name takes
-precedence without a collision warning. `--no-skills` disables this fallback too. No separate CLI
-installation is needed. npm must be available with a writable global prefix, as for a normal npm
-CLI installation. Merely loading the extension does not install software.
-
-If you already have Magnitude and a local model, connect directly:
+Install the extension:
 
 ```sh
-magnitude connections add pi
+pi install npm:@magnitudedev/pi-extension
 ```
 
-Restart Pi or run `/reload` after connecting. `PI_CODING_AGENT_DIR`, if set, is honored.
-Installing the package directly does not configure provider models,
-install the Magnitude CLI, or start its service; the connection command
-does all connection configuration and can be run safely after a standalone package install.
+Open Pi and accept the setup offer. Magnitude walks you through the best models for your machine,
+downloads your selection, and connects it to Pi. You don't need Magnitude installed beforehand.
 
-The extension bundles Magnitude's private SDK. Model status, loading, and stopping use the existing
-RPC endpoint at port 10100. When necessary the SDK runs `magnitude service start`; it does not use
-CLI output as a model API. If `/stop-model` encounters a protocol mismatch, the
-extension runs `magnitude connections sync pi` once to install the exact plugin version selected by
-the installed CLI, then reloads Pi. Retry your model command after reload; it is never replayed
-automatically. Failed sync reports the error without reloading or looping. Manually owned incompatible
-packages are not replaced. Autocomplete and inference callbacks never trigger an update. During
-requests to the `magnitude` provider, it opts into Magnitude progress events and uses Pi's working
-row for model loading, prefill, and active-work timing. When Pi successfully completes a run, a one-line summary
-immediately above the editor shows the model's display name, total Pi agent-run time, first-token
-latency, and token-weighted generation throughput. Pi extensions execute with your user permissions.
+You can also start setup anytime with `/magnitude-setup`.
 
-Commands:
+Requires Pi 0.83.0 or newer. Magnitude supports macOS and Linux, and Windows through WSL.
+An internet connection is needed for installation and model downloads; after that, you can work offline.
 
-- `/magnitude-setup` — open Magnitude's graphical model setup inside Pi
-- `/stop-model` — stop the active model
+## Why Magnitude?
 
-Installed Magnitude models appear in Pi's built-in `/model` selector. To discover, compare, install,
-or remove models from the Magnitude catalog, ask the agent; the connection installs Magnitude's
-agent skill and the agent uses the `magnitude catalog` and `magnitude connections` commands.
+- **Free to run:** no token costs, API keys, or rate limits
+- **Private and offline:** local model requests stay on your machine
+- **Recommends what fits:** the best models for your hardware, with estimated tok/s
+- **Tuned end to end:** inference settings chosen for your machine
+- **Models on demand:** loaded when Pi needs them, unloaded when idle or memory gets tight
+- **Live performance stats:** see model loading, prompt processing, and time spent working
 
-Set `MAGNITUDE_CLI` to an alternate Magnitude executable path when developing or testing the package.
-`magnitude connections add pi` selects an exact compatible package and verifies its bundled contents.
-The SDK is a build-time workspace dependency, not a separately published or installed package.
+After each completed run, a summary shows the model, time worked, time to first token, and tokens per
+second. It stays in your chat history so you can refer back to it.
 
-From a Magnitude source checkout, run the complete local connection and TUI flow with:
+## Using your models
 
-```sh
-bun run dev:pi
+Choose an installed Magnitude model from Pi's `/model` selector. To discover or install more models,
+ask your agent:
+
+```text
+Use Magnitude to recommend the best local models for my hardware and help me install one.
 ```
 
-This builds and installs the package from `integrations/pi` into an isolated Pi configuration,
-with temporary connection receipts and agent skill. Pi runs in the caller's working directory.
-It uses the normal connection service,
-builds and runs the checkout's inference runtime,
-and keeps the current source CLI available until Pi exits. Exiting Pi stops the development runtime
-and restores the service state that existed before launch. The launcher inherits the current
-environment; it does not start or configure tracing.
+Use `/magnitude-setup` to run guided setup again, or `/stop-model` to unload the active model and
+free its memory.
+
+### Already using Magnitude?
 
-To test the first-run setup offer with no preconfigured Magnitude provider:
+Connect your installed models to Pi:
 
 ```sh
-bun run dev:pi --setup
+magnitude connections add pi
 ```
 
-This installs only the checkout's package into the temporary Pi profile. Accept the setup offer,
-choose a model, and return to Pi to chat. Both development modes keep connection files and skills
-inside the temporary profile, and do not change login-startup registration. They share the machine's
-real model storage and inference service: downloads consume disk space and selected models use
-memory. The launcher restores the prior managed service after Pi exits. Ordinary installed setup
-does enable login startup.
+Then restart Pi or run `/reload`.
+
+## Learn more
+
+- [Documentation](https://docs.magnitude.dev)
+- [GitHub](https://github.com/magnitudedev/magnitude)
+- [Discord](https://discord.gg/EHt48pPWdC)
+- [Report an issue](https://github.com/magnitudedev/magnitude/issues)

package/dist/magnitude-plugin.json

@@ -1,11 +1,11 @@
 {
   "name": "@magnitudedev/pi-extension",
-  "version": "0.0.1",
+  "version": "0.0.3-alpha.0",
   "rpcVersion": 1,
-  "contentFingerprint": "3c0ea7c8e8d3a14eba260a94ba16b488550a04860c3c275f2f58a8da575cc439",
+  "contentFingerprint": "8de1ffd943ecccad03f811d1b61bad853c2f0fb249308e8aecd00a8a504ed7fd",
   "files": {
-    "README.md": "26fa7e5b56c9b171946b7efec036703e258ab51607d1e20f00c45d6e96133a29",
-    "dist/magnitude.js": "b21c625dd7e2c0f00c6992845dad09cd753b4e85cf5b258d334ba4a4c6d065c3",
+    "README.md": "c6a121075d1ccacc4db063dd8ff1a336a04f77a7f444acba12e1628df32fa3f5",
+    "dist/magnitude.js": "e23b9692b7cd00bd01a68ba1bfd2c32a83c22017fa964008049b5de30c35a5cb",
     "dist/skills/magnitude/SKILL.md": "37de67f0c7b831415f6298c8785b7ae97d5cfe454dc778651d96114840d2ace2"
   }
 }

package/dist/magnitude.js

@@ -5985,18 +5985,21 @@ var PiSetupLive = Layer6.effect(PiSetup, Effect12.gen(function* () {
   const fs = yield* FileSystem.FileSystem;
   const executor = yield* CommandExecutor3.CommandExecutor;
   return {
-    run: (ctx) => Effect12.scoped(Effect12.gen(function* () {
+    run: (ctx, activateModel) => Effect12.scoped(Effect12.gen(function* () {
       const executable = yield* withPiPreparation(ctx, (setMessage) => prepareMagnitudeCli(ctx.cwd, setMessage));
-      const termination = yield* withPiTerminal(ctx, runInteractiveProcess({
-        executable,
-        args: ["setup", "--host", "pi"],
-        environment: process.env,
-        workingDirectory: ctx.cwd
+      return yield* withPiTerminal(ctx, Effect12.gen(function* () {
+        const termination = yield* runInteractiveProcess({
+          executable,
+          args: ["setup", "--host", "pi"],
+          environment: process.env,
+          workingDirectory: ctx.cwd
+        });
+        if (!(yield* validateSetupTermination(termination)))
+          return { _tag: "Cancelled" };
+        const modelId = yield* readSetupModel.pipe(Effect12.provide(MagnitudeClient.layer({ autoStart: false }).pipe(Layer6.provide(FetchHttpClient2.layer))));
+        yield* activateModel(modelId);
+        return { _tag: "Completed", modelId };
       }));
-      if (!(yield* validateSetupTermination(termination)))
-        return { _tag: "Cancelled" };
-      const modelId = yield* readSetupModel.pipe(Effect12.provide(MagnitudeClient.layer({ autoStart: false }).pipe(Layer6.provide(FetchHttpClient2.layer))));
-      return { _tag: "Completed", modelId };
     })).pipe(Effect12.provideService(CommandExecutor3.CommandExecutor, executor), Effect12.provideService(FileSystem.FileSystem, fs), Effect12.mapError((error) => error instanceof PiSetupFailed ? error : failure(`Magnitude setup could not finish: ${String(error)}`)))
   };
 }));
@@ -6010,19 +6013,16 @@ var registerMagnitudeSetup = (pi, layer4 = PiSetupLive.pipe(Layer6.provide(NodeC
     if (!ctx.isIdle() || ctx.hasPendingMessages())
       return yield* failure("Wait for the current task to finish, then run /magnitude-setup.");
     const setup = yield* PiSetup;
-    const result = yield* setup.run(ctx);
-    if (result._tag !== "Completed")
-      return false;
-    yield* Effect12.tryPromise({
+    const result = yield* setup.run(ctx, (modelId) => Effect12.tryPromise({
       try: async () => {
         await ctx.modelRegistry.refresh();
-        const model2 = ctx.modelRegistry.find("magnitude", result.modelId);
+        const model2 = ctx.modelRegistry.find("magnitude", modelId);
         if (!model2 || !await pi.setModel(model2))
           throw new Error("The selected model is not available in Pi");
       },
       catch: (error) => failure(`Magnitude setup completed, but Pi could not activate the model: ${String(error)}. Run /reload and select it with /model.`)
-    });
-    return true;
+    }));
+    return result._tag === "Completed";
   });
   const run = (ctx) => runtime.runPromise(Effect12.forkIn(gate.withPermitsIfAvailable(1)(action(ctx)).pipe(Effect12.flatMap((result) => result._tag === "Some" ? Effect12.succeed(result.value) : Effect12.fail(failure("Magnitude setup is already open."))), Effect12.catchAll((error) => Effect12.sync(() => {
     ctx.ui.notify(error.message, "error");
@@ -6238,9 +6238,16 @@ var makeObservingFetch = (fetchImplementation, begin, scope) => {
 };
 
 // extensions/progress.ts
-import { Text } from "@earendil-works/pi-tui";
 import { Data as Data3, Effect as Effect15, Fiber as Fiber3, Option as Option17, Queue, Schema as Schema55 } from "effect";
-var MAGNITUDE_SUMMARY_WIDGET_KEY = "magnitude-inference-summary";
+var MAGNITUDE_SUMMARY_ENTRY_TYPE = "magnitude-inference-summary";
+var Milliseconds = Schema55.Number.pipe(Schema55.finite(), Schema55.nonNegative());
+var ProgressSummary = Schema55.Struct({
+  modelName: Schema55.String,
+  elapsedMs: Milliseconds,
+  ttftMs: Milliseconds,
+  generatedTokens: Schema55.Number.pipe(Schema55.int(), Schema55.nonNegative()),
+  decodeMs: Milliseconds
+});
 var RequestId = Schema55.Number.pipe(Schema55.int(), Schema55.brand("ProgressRequestId"));
 
 class Observing extends Data3.TaggedClass("Observing") {
@@ -6276,27 +6283,28 @@ var runMachine = defineFSM({ Idle: Idle2, Working, Settled, Disposed }, {
 });
 var seconds = (ms) => `${(Math.max(0, ms) / 1000).toFixed(1)}s`;
 var count = (n) => n < 1000 ? String(Math.round(n)) : `${(n / (n < 1e6 ? 1000 : 1e6)).toFixed(1).replace(/\.0$/, "")}${n < 1e6 ? "k" : "m"}`;
-var duration = (ms) => {
+var formatElapsed = (ms) => {
   const s = Math.floor(Math.max(0, ms) / 1000);
-  return s === 0 ? "<1 second" : s < 60 ? `${s} second${s === 1 ? "" : "s"}` : s % 60 === 0 ? `${s / 60} minute${s === 60 ? "" : "s"}` : `${Math.floor(s / 60)}:${String(s % 60).padStart(2, "0")}`;
+  return s < 60 ? `${s}s` : `${Math.floor(s / 60)}m ${s % 60}s`;
 };
+var formatSummary = (summary) => `● ${summary.modelName} worked for ${summary.elapsedMs < 1000 ? "<1s" : formatElapsed(summary.elapsedMs)}` + ` · ${seconds(summary.ttftMs)} TTFT` + (summary.decodeMs > 0 && summary.generatedTokens > 0 ? ` · ${(summary.generatedTokens * 1000 / summary.decodeMs).toFixed(1)} tok/s` : "");
 var formatLiveProgress = ({ progress, modelName, startedAt }, now) => {
   switch (progress.phase) {
     case "queued":
     case "preparing":
       return;
     case "model_loading":
-      return `Loading ${modelName} into memory · ${Math.round(Math.max(0, Math.min(1, progress.fraction)) * 100)}% · ${seconds(now - startedAt)}`;
+      return `Loading ${modelName} into memory · ${Math.round(Math.max(0, Math.min(1, progress.fraction)) * 100)}% · ${formatElapsed(now - startedAt)}`;
     case "generating":
-      return `Working · ${seconds(now - startedAt)}`;
+      return `Working · ${formatElapsed(now - startedAt)}`;
     case "prefill": {
       const cached = Math.min(progress.cached_tokens, progress.total_tokens);
       const completed = Math.min(Math.max(progress.completed_tokens, cached), progress.total_tokens);
-      return `Prefilling prompt · ${count(completed - cached)} / ${count(progress.total_tokens - cached)} tokens · ${count(cached)} cached · ${seconds(now - startedAt)}`;
+      return `Prefilling prompt · ${count(completed - cached)} / ${count(progress.total_tokens - cached)} tokens · ${count(cached)} cached · ${formatElapsed(now - startedAt)}`;
     }
   }
 };
-var makeProgressTracker = (ui, now = () => performance.now()) => Effect15.gen(function* () {
+var makeProgressTracker = (ui, appendSummary, now = () => performance.now()) => Effect15.gen(function* () {
   let state = new Idle2;
   let nextId = 0;
   let active;
@@ -6304,7 +6312,6 @@ var makeProgressTracker = (ui, now = () => performance.now()) => Effect15.gen(fu
   let nextResponseId = 0;
   const wake = yield* Queue.sliding(1);
   const present = (f) => Effect15.sync(f).pipe(Effect15.catchAllCause(() => Effect15.void));
-  const clearSummary = present(() => ui.setWidget(MAGNITUDE_SUMMARY_WIDGET_KEY, undefined));
   const resetRow = present(() => ui.setWorkingMessage());
   const render2 = present(() => {
     if (active)
@@ -6320,14 +6327,17 @@ var makeProgressTracker = (ui, now = () => performance.now()) => Effect15.gen(fu
     const settled = state;
     state = runMachine.transition(settled, "Idle", {});
     const timings = [...settled.run.completed.entries()].filter(([id]) => settled.run.accepted.has(id)).sort(([a], [b]) => a - b).map(([, value]) => value);
-    if ([...settled.run.responses.values()].some((outcome) => !Option17.getOrElse(outcome, () => false)) || timings.length === 0) {
-      yield* clearSummary;
+    if ([...settled.run.responses.values()].some((outcome) => !Option17.getOrElse(outcome, () => false)) || timings.length === 0)
       return;
-    }
     const tokens = timings.reduce((sum, t) => sum + t.predicted_n, 0);
     const decodeMs = timings.reduce((sum, t) => sum + t.predicted_ms, 0);
-    const summary = `● ${settled.run.modelName} worked for ${duration(settled.settledAt - settled.run.startedAt)}` + ` · ${seconds(timings[0].time_to_first_token_ms)} TTFT` + (decodeMs > 0 && tokens > 0 ? ` · ${(tokens * 1000 / decodeMs).toFixed(1)} tok/s` : "");
-    yield* present(() => ui.setWidget(MAGNITUDE_SUMMARY_WIDGET_KEY, (_tui, theme) => new Text(theme.fg("muted", summary), 0, 0)));
+    yield* present(() => appendSummary(ProgressSummary.make({
+      modelName: settled.run.modelName,
+      elapsedMs: Math.max(0, settled.settledAt - settled.run.startedAt),
+      ttftMs: timings[0].time_to_first_token_ms,
+      generatedTokens: tokens,
+      decodeMs
+    })));
   });
   const clear = Effect15.gen(function* () {
     if (state._tag === "Disposed")
@@ -6337,7 +6347,6 @@ var makeProgressTracker = (ui, now = () => performance.now()) => Effect15.gen(fu
     active = undefined;
     latest = undefined;
     yield* resetRow;
-    yield* clearSummary;
   });
   const startRun = (modelName) => Effect15.gen(function* () {
     if (state._tag === "Disposed")
@@ -6347,7 +6356,6 @@ var makeProgressTracker = (ui, now = () => performance.now()) => Effect15.gen(fu
     if (state._tag !== "Idle")
       return;
     state = runMachine.transition(state, "Working", { run: { startedAt: now(), modelName, requests: new Map, completed: new Map, responses: new Map, accepted: new Set } });
-    yield* clearSummary;
   });
   const timer = yield* Effect15.forever(Effect15.gen(function* () {
     yield* Queue.take(wake);
@@ -6395,7 +6403,6 @@ var makeProgressTracker = (ui, now = () => performance.now()) => Effect15.gen(fu
         if (!successful && latest !== undefined && requests.includes(latest)) {
           active = undefined;
           yield* resetRow;
-          yield* clearSummary;
         }
         yield* finalize;
       });
@@ -6459,8 +6466,13 @@ var makeProgressTracker = (ui, now = () => performance.now()) => Effect15.gen(fu
 });
 
 // extensions/magnitude.ts
-import { Effect as Effect16, Exit as Exit5, Scope as Scope7 } from "effect";
+import { Text } from "@earendil-works/pi-tui";
+import { Effect as Effect16, Exit as Exit5, Option as Option18, Schema as Schema56, Scope as Scope7 } from "effect";
 function magnitudeExtension(pi) {
+  pi.registerEntryRenderer(MAGNITUDE_SUMMARY_ENTRY_TYPE, (entry, _options, theme) => {
+    const summary = Schema56.decodeUnknownOption(ProgressSummary)(entry.data);
+    return Option18.isSome(summary) ? new Text(theme.fg("muted", formatSummary(summary.value)), 0, 0) : undefined;
+  });
   const completions = openAICompletionsApi();
   let tracker;
   let scope;
@@ -6487,7 +6499,7 @@ function magnitudeExtension(pi) {
     if (scope)
       await Effect16.runPromise(Scope7.close(scope, Exit5.void));
     scope = Effect16.runSync(Scope7.make());
-    tracker = await Effect16.runPromise(makeProgressTracker(ctx.ui).pipe(Scope7.extend(scope)));
+    tracker = await Effect16.runPromise(makeProgressTracker(ctx.ui, (summary) => pi.appendEntry(MAGNITUDE_SUMMARY_ENTRY_TYPE, summary)).pipe(Scope7.extend(scope)));
   });
   pi.on("model_select", (event) => {
     if (event.model.provider !== "magnitude")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magnitudedev/pi-extension",
-  "version": "0.0.1",
+  "version": "0.0.3-alpha.0",
   "description": "Run local AI models in Pi with Magnitude",
   "type": "module",
   "license": "MIT",