pi-telegram-plus 0.0.1

package/lib/commands/info.ts

@@ -0,0 +1,158 @@
+import { existsSync } from "node:fs";
+import type { CommandRegistry } from "./register.ts";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { escapeHtml } from "../html.ts";
+import type { CapturedAgentSession } from "../types.ts";
+
+/**
+ * All command handlers capture ctx.ui at entry and use the captured reference.
+ * See model.ts for explanation.
+ */
+export function registerInfoCommands(
+  registry: CommandRegistry,
+  deps: { getSession: () => CapturedAgentSession | undefined },
+): void {
+  // ── /copy ──────────────────────────────────────────────────────────────
+  registry.registerCommand("copy", {
+    description: "Show last assistant message (for Telegram copy)",
+    handler: async (_args, ctx) => {
+      const ui = ctx.ui;
+      const session = deps.getSession();
+      if (!session) {
+        ui.notify("No active session", "error");
+        return;
+      }
+      const text = session.getLastAssistantText();
+      ui.notify(text ? text : "No assistant message to copy.", "info");
+    },
+  });
+
+  // ── /export ────────────────────────────────────────────────────────────
+  registry.registerCommand("export", {
+    description: "Export session to HTML or JSONL",
+    handler: async (args, ctx) => {
+      const ui = ctx.ui;
+      const session = deps.getSession();
+      if (!session) {
+        ui.notify("No active session", "error");
+        return;
+      }
+      try {
+        if (args?.endsWith(".jsonl")) {
+          const path = session.exportToJsonl(args);
+          ui.notify(`Exported to: ${path}`, "info");
+        } else {
+          const path = await session.exportToHtml(args || undefined);
+          ui.notify(`Exported to: ${escapeHtml(path)}`, "info");
+        }
+      } catch (error) {
+        ui.notify(`Export failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+      }
+    },
+  });
+
+  // ── /import ───────────────────────────────────────────────────────────
+  registry.registerCommand("import", {
+    description: "Import a session JSONL file (path on server)",
+    handler: async (args, ctx) => {
+      const ui = ctx.ui;
+      const session = deps.getSession();
+      if (!session) {
+        ui.notify("No active session", "error");
+        return;
+      }
+      const path = args || await ui.input("Session file path (JSONL on server)", "/path/to/session.jsonl");
+      if (!path) return;
+      if (!existsSync(path)) {
+        ui.notify(`File not found: ${escapeHtml(path)}`, "error");
+        return;
+      }
+      try {
+        const { SessionManager: SM } = await import("@earendil-works/pi-coding-agent");
+        const sm = SM.open(path);
+        ui.notify(`Imported session: ${sm.getSessionId()}\nUse /resume to switch to it.`, "info");
+      } catch (error) {
+        ui.notify(`Import failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+      }
+    },
+  });
+
+  // ── /share ────────────────────────────────────────────────────────────
+  registry.registerCommand("share", {
+    description: "Export session for sharing (requires gh CLI on server)",
+    handler: async (_args, ctx) => {
+      const ui = ctx.ui;
+      const session = deps.getSession();
+      if (!session) {
+        ui.notify("No active session", "error");
+        return;
+      }
+      try {
+        const path = await session.exportToHtml();
+        ui.notify(
+          [
+            `Session exported to: ${escapeHtml(path)}`,
+            "",
+            "To share via GitHub Gist, run on the server:",
+            `gh gist create --public=false "${path}"`,
+          ].join("\n"),
+          "info",
+        );
+      } catch (error) {
+        ui.notify(`Export failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+      }
+    },
+  });
+
+  // ── /changelog ────────────────────────────────────────────────────────
+  registry.registerCommand("changelog", {
+    description: "Show changelog link",
+    handler: async (_args, ctx) => {
+      const ui = ctx.ui;
+      ui.notify("Changelog: https://github.com/earendil-works/pi-coding-agent/releases", "info");
+    },
+  });
+
+  // ── /hotkeys ──────────────────────────────────────────────────────────
+  registry.registerCommand("hotkeys", {
+    description: "Show keyboard shortcuts (TUI feature list)",
+    handler: async (_args, ctx) => {
+      const ui = ctx.ui;
+      ui.notify(
+        [
+          "Keyboard Shortcuts (TUI)",
+          "These are TUI-only. In Telegram, use slash commands.",
+          "",
+          "Send / to see available commands.",
+          "Send /model, /thinking, /compact, /new, etc.",
+        ].join("\n"),
+        "info",
+      );
+    },
+  });
+
+  // ── /debug ────────────────────────────────────────────────────────────
+  registry.registerCommand("debug", {
+    description: "Show debug information",
+    handler: async (_args, ctx) => {
+      const ui = ctx.ui;
+      const session = deps.getSession();
+      if (!session) {
+        ui.notify("No active session", "error");
+        return;
+      }
+      const entries = session.sessionManager.getEntries();
+      const model = session.model;
+      const lines = [
+        `Debug`,
+        `model: ${model ? `${model.provider}/${model.id}` : "(none)"}`,
+        `thinking: ${session.thinkingLevel}`,
+        `streaming: ${session.isStreaming}`,
+        `compacting: ${session.isCompacting}`,
+        `entries: ${entries.length}`,
+        `cwd: ${escapeHtml(ctx.cwd)}`,
+      ];
+      ui.notify(lines.join("\n"), "info");
+    },
+  });
+}

package/lib/commands/lifecycle.ts

@@ -0,0 +1,65 @@
+import type { CommandRegistry } from "./register.ts";
+
+/**
+ * All command handlers capture ctx.ui at entry and use the captured reference.
+ * See model.ts for explanation.
+ *
+ * For /compact specifically: ctx.compact() is fire-and-forget with async
+ * callbacks. The captured ui reference keeps TelegramUi alive via its closure
+ * over chatId + transport, so onComplete/onError always reach Telegram
+ * even after runner.uiContext has been restored to TUI.
+ */
+export function registerLifecycleCommands(registry: CommandRegistry): void {
+  // ── /compact ──────────────────────────────────────────────────────────
+  registry.registerCommand("compact", {
+    description: "Compact current session context",
+    handler: async (args, ctx) => {
+      const ui = ctx.ui;
+      ctx.compact({
+        customInstructions: args || undefined,
+        onComplete: () => {
+          ui.notify("✅ Compaction completed.", "info");
+        },
+        onError: (error: Error) => {
+          ui.notify(`Compaction failed: ${error.message}`, "error");
+        },
+      });
+      ui.notify("Compaction started.", "info");
+    },
+  });
+
+  // ── /reload ────────────────────────────────────────────────────────────
+  registry.registerCommand("reload", {
+    description: "Reload extensions, skills, prompts, and themes",
+    handler: async (_args, ctx) => {
+      const ui = ctx.ui;
+      ui.notify("Reloading…", "info");
+      await ctx.reload();
+      return;
+    },
+  });
+
+  // ── /stop ─────────────────────────────────────────────────────────────
+  registry.registerCommand("stop", {
+    description: "Stop the current agent turn",
+    handler: async (_args, ctx) => {
+      const ui = ctx.ui;
+      ctx.abort();
+      ui.notify("⏹ Stopped.", "info");
+    },
+  });
+
+  // ── /quit ──────────────────────────────────────────────────────────────
+  registry.registerCommand("quit", {
+    description: "Shut down pi",
+    handler: async (_args, ctx) => {
+      const ui = ctx.ui;
+      const confirmed = await ui.confirm("Quit", "Shut down pi?");
+      if (confirmed) {
+        ctx.shutdown();
+        ui.notify("Shutdown requested. If pi keeps running, stop it from the TUI/terminal.", "info");
+      }
+    },
+  });
+
+}

package/lib/commands/model.ts

@@ -0,0 +1,188 @@
+import type { Model } from "@earendil-works/pi-ai";
+import type { CommandRegistry } from "./register.ts";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { CapturedAgentSession } from "../types.ts";
+
+/**
+ * Safely set the model on the session.
+ * AgentSession.prototype.setModel() throws on auth failure;
+ * this helper catches the error and returns a user-friendly message.
+ */
+async function trySetModel(
+  session: CapturedAgentSession,
+  model: Model,
+): Promise<{ ok: true } | { ok: false; error: string }> {
+  try {
+    await session.setModel(model);
+    return { ok: true };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: message };
+  }
+}
+
+function formatModel(model: Model): string {
+  return `${model.provider}/${model.id}`;
+}
+
+/**
+ * All command handlers capture ctx.ui at entry and use the captured reference
+ * for notifications. This is critical because ctx.ui is a getter that reads
+ * runner.uiContext, which gets reset to TUI UI after rebindSession (triggered
+ * by newSession/fork/switchSession). The captured reference keeps the TelegramUi
+ * alive via its closure over chatId + transport.
+ */
+export function registerModelCommands(
+  registry: CommandRegistry,
+  deps: { getSession: () => CapturedAgentSession | undefined },
+): void {
+  // ── /model ────────────────────────────────────────────────────────────
+  registry.registerCommand("model", {
+    description: "Show or change the current model",
+    handler: async (args, ctx) => {
+      const ui = ctx.ui;
+      const session = deps.getSession();
+      if (!session) {
+        ui.notify("No active session", "error");
+        return;
+      }
+
+      if (args) {
+        const needle = args.toLowerCase();
+        // Prefer available (auth'd) models, fall back to all models so
+        // the user gets a clear auth error instead of "not found".
+        const model =
+          session.modelRegistry.getAvailable().find((m) => {
+            const ref = formatModel(m).toLowerCase();
+            return ref === needle || m.id.toLowerCase() === needle || ref.includes(needle);
+          }) ??
+          session.modelRegistry.getAll().find((m) => {
+            const ref = formatModel(m).toLowerCase();
+            return ref === needle || m.id.toLowerCase() === needle || ref.includes(needle);
+          });
+        if (!model) {
+          ui.notify(`Model not found: ${args}`, "error");
+          return;
+        }
+        const result = await trySetModel(session, model);
+        if (result.ok) {
+          ui.notify(`Model set: ${formatModel(model)}`, "info");
+        } else {
+          ui.notify(result.error, "error");
+        }
+        return;
+      }
+
+      const available = session.modelRegistry.getAvailable();
+      if (available.length === 0) {
+        ui.notify("No authenticated models available. Use /login to add an API key.", "error");
+        return;
+      }
+
+      const shown = available;
+      const current = session.model;
+      const labels = shown.map((m) =>
+        (current && formatModel(current) === formatModel(m) ? "● " : "  ") + formatModel(m),
+      );
+      const choice = await ui.select("Select model", labels);
+      if (!choice) return;
+      const index = labels.indexOf(choice);
+      if (index < 0 || index >= shown.length) return;
+      const selected = shown[index];
+      const result = await trySetModel(session, selected);
+      if (result.ok) {
+        ui.notify(`Model set: ${formatModel(selected)}`, "info");
+      } else {
+        ui.notify(result.error, "error");
+      }
+    },
+  });
+
+  // ── /scoped-models ───────────────────────────────────────────────────
+  registry.registerCommand("scoped-models", {
+    description: "Show or select from scoped models",
+    handler: async (_args, ctx) => {
+      const ui = ctx.ui;
+      const session = deps.getSession();
+      if (!session) {
+        ui.notify("No active session", "error");
+        return;
+      }
+
+      const scoped = session.scopedModels;
+      if (!scoped || scoped.length === 0) {
+        const allModels = session.modelRegistry.getAvailable();
+        if (allModels.length === 0) {
+          ui.notify("No authenticated models. Use /login to add an API key.", "info");
+          return;
+        }
+        const labels = allModels.map((m) => formatModel(m));
+        const choice = await ui.select("No scoped models. Set one?", labels);
+        if (!choice) return;
+        const idx = labels.indexOf(choice);
+        if (idx < 0) return;
+        const selected = allModels[idx];
+        const setResult = await trySetModel(session, selected);
+        if (!setResult.ok) {
+          ui.notify(setResult.error, "error");
+          return;
+        }
+        session.setScopedModels([{ model: selected }]);
+        ui.notify(`Scoped to ${formatModel(selected)}`, "info");
+        return;
+      }
+
+      const labels = scoped.map((sm) =>
+        formatModel(sm.model) + (sm.thinkingLevel ? ` (${sm.thinkingLevel})` : ""),
+      );
+      const choice = await ui.select("Scoped models", labels);
+      if (!choice) return;
+      const index = labels.indexOf(choice);
+      if (index < 0 || index >= scoped.length) return;
+      const sm = scoped[index];
+      const switchResult = await trySetModel(session, sm.model);
+      if (!switchResult.ok) {
+        ui.notify(switchResult.error, "error");
+        return;
+      }
+      if (sm.thinkingLevel) session.setThinkingLevel(sm.thinkingLevel);
+      ui.notify(`Switched to ${formatModel(sm.model)}`, "info");
+    },
+  });
+
+  // ── /thinking ────────────────────────────────────────────────────────
+  registry.registerCommand("thinking", {
+    description: "Show or change thinking level",
+    handler: async (args, ctx) => {
+      const ui = ctx.ui;
+      const session = deps.getSession();
+      if (!session) {
+        ui.notify("No active session", "error");
+        return;
+      }
+
+      if (args) {
+        session.setThinkingLevel(args as any);
+        ui.notify(`Thinking level set: ${args}`, "info");
+        return;
+      }
+
+      const levels = session.getAvailableThinkingLevels();
+      if (levels.length === 0) {
+        ui.notify("Current model does not support thinking levels.", "info");
+        return;
+      }
+
+      const current = session.thinkingLevel;
+      const labels = levels.map((l) =>
+        (l === current ? "● " : "  ") + String(l),
+      );
+      const choice = await ui.select("Thinking level", labels);
+      if (!choice) return;
+      const selected = levels[labels.indexOf(choice)];
+      if (selected === undefined) return;
+      session.setThinkingLevel(selected);
+      ui.notify(`Thinking level set: ${selected}`, "info");
+    },
+  });
+}

package/lib/commands/register.ts

@@ -0,0 +1,40 @@
+import type { CapturedAgentSession } from "../types.ts";
+import { registerModelCommands } from "./model.ts";
+import { registerSessionCommands } from "./session.ts";
+import { registerAuthCommands } from "./auth.ts";
+import { registerInfoCommands } from "./info.ts";
+import { registerLifecycleCommands } from "./lifecycle.ts";
+import { registerSettingsCommands } from "./settings.ts";
+import { registerTgConfigCommands } from "./tg-config.ts";
+
+export type CommandRegistry = {
+  registerCommand: (name: string, options: { description?: string; handler: (args: string, ctx: any) => Promise<void> }) => void;
+};
+
+/** Minimal base deps — most commands only need session access. */
+export type SessionDeps = {
+  getSession: () => CapturedAgentSession | undefined;
+};
+
+/** Extended deps for session commands that also manage session names. */
+export type SessionNameDeps = SessionDeps & {
+  setSessionName: (name: string) => void;
+  getSessionName: () => string | undefined;
+};
+
+/** Deps for tg-config command. */
+export type TgConfigDeps = SessionDeps & {
+  getConfig: () => import("../types.ts").TelegramConfig;
+  setConfig: (c: import("../types.ts").TelegramConfig) => void;
+  persistConfig: (c: import("../types.ts").TelegramConfig) => Promise<void>;
+};
+
+export function registerAllCommands(registry: CommandRegistry, sessionDeps: SessionDeps, sessionNameDeps: SessionNameDeps, tgConfigDeps?: TgConfigDeps): void {
+  registerSettingsCommands(registry, sessionDeps);
+  registerModelCommands(registry, sessionDeps);
+  registerSessionCommands(registry, sessionNameDeps);
+  registerAuthCommands(registry, sessionDeps);
+  registerInfoCommands(registry, sessionDeps);
+  registerLifecycleCommands(registry);
+  if (tgConfigDeps) registerTgConfigCommands(registry, tgConfigDeps);
+}