@pi-unipi/unipi 3.0.0-alpha.2 → 3.0.0-alpha.21

package/packages/image/src/tools.ts

@@ -1,326 +0,0 @@
-/**
- * @pi-unipi/image — Agent tool registration
- *
- * Registers `image_generate` and `image_recognize`. Each tool is registered
- * only when enabled in config, so a user who wants just one does not have the
- * other consuming context in the system prompt.
- */
-
-import { Type } from "typebox";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { IMAGE_TOOLS } from "@pi-unipi/core";
-
-import { generateImage } from "./generate.js";
-import { loadImage } from "./image-source.js";
-import { registerRegistryImageProviders } from "./register-providers.js";
-import {
-  findProviderBaseUrl,
-  formatModelRef,
-  listAllImageGenModels,
-  resolveImageGenModel,
-  resolveVisionModel,
-  type ChatModelRegistry,
-  type VisionModel,
-} from "./models.js";
-import { recognizeImage } from "./recognize.js";
-import { getOutputDir, loadConfig } from "./settings.js";
-
-/** Error shape shared by both tools. */
-function errorResult(message: string) {
-  return {
-    content: [{ type: "text" as const, text: message }],
-    isError: true,
-    details: {},
-  };
-}
-
-function messageOf(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
-/** Read the chat model registry off the extension context. */
-function getRegistry(ctx: ExtensionContext): ChatModelRegistry | undefined {
-  return (ctx as unknown as { modelRegistry?: ChatModelRegistry }).modelRegistry;
-}
-
-/** Resolve an API key for a provider through pi's auth storage. */
-async function resolveApiKey(
-  registry: ChatModelRegistry | undefined,
-  provider: string,
-): Promise<string | undefined> {
-  try {
-    const key = await registry?.getApiKeyForProvider?.(provider);
-    if (key) return key;
-  } catch {
-    // Fall through to the environment.
-  }
-
-  const envName = `${provider.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_API_KEY`;
-  return process.env[envName] || undefined;
-}
-
-/** Look up the full pi-ai model object for a vision model. */
-function findChatModel(
-  registry: ChatModelRegistry,
-  model: VisionModel,
-): { baseUrl?: string; api?: string } | undefined {
-  try {
-    return registry.find(model.provider, model.id) as
-      | { baseUrl?: string; api?: string }
-      | undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-export function registerImageTools(pi: ExtensionAPI): void {
-  const config = loadConfig();
-
-  if (config.generate.enabled) registerGenerateTool(pi);
-  if (config.recognize.enabled) registerRecognizeTool(pi);
-}
-
-function registerGenerateTool(pi: ExtensionAPI): void {
-  pi.registerTool({
-    name: IMAGE_TOOLS.GENERATE,
-    label: "Generate Image",
-    description:
-      "Generate an image from a text prompt, or edit an existing image by " +
-      "passing `image`. The result is returned inline and, when enabled, saved to disk.",
-    promptSnippet: "Generate an image from a text prompt.",
-    promptGuidelines: [
-      "Use image_generate to create images from a text description.",
-      "Write a detailed prompt — subject, style, composition and lighting all help.",
-      "Pass `image` to edit an existing image instead of generating a new one.",
-      "Editing regenerates the whole image, so unmentioned details may change.",
-      "Describe what you DO want; negation is unreliable in image models.",
-      "Omit model to use the one configured in /unipi:settings.",
-      "Generated images cost money per call; do not regenerate without being asked.",
-    ],
-    parameters: Type.Object({
-      prompt: Type.String({
-        description: "Description of the image to generate. Be specific.",
-      }),
-      image: Type.Optional(
-        Type.String({
-          description:
-            "Source image to edit: a local file path, data: URL, or base64 data. " +
-            "When set, the model edits this image instead of generating from scratch.",
-        }),
-      ),
-      model: Type.Optional(
-        Type.String({
-          description:
-            'Image model override, e.g. "flux.2-pro" or ' +
-            '"openrouter/google/gemini-3-pro-image". Omit to use the configured default.',
-        }),
-      ),
-    }),
-    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      try {
-        const config = loadConfig();
-        const registry = getRegistry(ctx);
-        // Bridge pi's own providers into pi-ai's images collection so the user
-        // is not forced onto OpenRouter. Idempotent and best-effort.
-        await registerRegistryImageProviders(registry);
-        // Include image models contributed by registered providers, so the
-        // tool can resolve anything the settings picker offers.
-        const models = await listAllImageGenModels(registry);
-
-        const requested = params.model?.trim() || config.generate.model;
-        const maybeResolved = resolveImageGenModel(requested, models);
-        if (typeof maybeResolved === "string") return errorResult(maybeResolved);
-
-        // A model may arrive without an endpoint — notably a user-typed
-        // "provider/model-id", accepted at face value. Fill it in from the
-        // registry so the adapter knows where to POST.
-        const registryBaseUrl = maybeResolved.baseUrl
-          ? undefined
-          : findProviderBaseUrl(registry, maybeResolved.provider);
-        const resolved = registryBaseUrl
-          ? { ...maybeResolved, baseUrl: registryBaseUrl }
-          : maybeResolved;
-
-        // pi-ai resolves image auth from its own credential store; only fall
-        // back to pi's chat-provider key when that comes up empty.
-        const fallbackKey = await resolveApiKey(registry, resolved.provider);
-
-        // An input image switches the request into edit mode.
-        const sourceImage = params.image?.trim()
-          ? loadImage(params.image, ctx.cwd ?? process.cwd())
-          : undefined;
-
-        const result = await generateImage({
-          prompt: params.prompt,
-          model: resolved,
-          ...(fallbackKey ? { apiKey: fallbackKey } : {}),
-          ...(sourceImage ? { inputImage: sourceImage } : {}),
-          signal,
-          outputDir: config.generate.saveToDisk ? getOutputDir(config) : undefined,
-        });
-
-        const saved = result.images
-          .map((image) => image.path)
-          .filter((path): path is string => Boolean(path));
-
-        const summary = [
-          `${sourceImage ? "Edited" : "Generated"} ${result.images.length} ` +
-            `image${result.images.length === 1 ? "" : "s"} with ${formatModelRef(resolved)}.`,
-          saved.length > 0 ? `Saved to:\n${saved.map((p) => `  ${p}`).join("\n")}` : "",
-          config.generate.saveToDisk && saved.length === 0
-            ? "Could not write to the output directory — returning the image inline only."
-            : "",
-          result.text,
-        ]
-          .filter(Boolean)
-          .join("\n");
-
-        return {
-          content: [
-            { type: "text" as const, text: summary },
-            ...result.images.map((image) => ({
-              type: "image" as const,
-              data: image.data,
-              mimeType: image.mimeType,
-            })),
-          ],
-          details: {
-            model: formatModelRef(resolved),
-            count: result.images.length,
-            paths: saved,
-          },
-        };
-      } catch (error) {
-        return errorResult(`Image generation failed: ${messageOf(error)}`);
-      }
-    },
-  });
-}
-
-function registerRecognizeTool(pi: ExtensionAPI): void {
-  pi.registerTool({
-    name: IMAGE_TOOLS.RECOGNIZE,
-    label: "Recognize Image",
-    description:
-      "Analyze an image and answer questions about it using a vision model. " +
-      "Accepts a local file path, a data: URL, or base64 image data.",
-    promptSnippet: "Analyze an image and answer questions about it.",
-    promptGuidelines: [
-      "Use image_recognize to read screenshots, diagrams, mockups and photos.",
-      "Pass a local file path whenever possible — it is cheaper than inlining base64.",
-      "Ask a specific question in `prompt` to focus the analysis.",
-      "Remote URLs are not fetched; download the image first.",
-    ],
-    parameters: Type.Object({
-      image: Type.String({
-        description:
-          "Local file path, data: URL, or base64 image data. " +
-          "Supported types: PNG, JPEG, GIF, WebP.",
-      }),
-      prompt: Type.Optional(
-        Type.String({
-          description:
-            "What to ask about the image. Defaults to a general description.",
-        }),
-      ),
-      model: Type.Optional(
-        Type.String({
-          description:
-            "Vision model override. Must accept image input. " +
-            "Omit to use the configured default or the current session model.",
-        }),
-      ),
-      systemPrompt: Type.Optional(
-        Type.String({
-          description:
-            "Override the configured system prompt for this call only.",
-        }),
-      ),
-    }),
-    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      try {
-        const config = loadConfig();
-
-        const registry = getRegistry(ctx);
-        if (!registry) {
-          return errorResult(
-            "Model registry unavailable — image_recognize needs an active session.",
-          );
-        }
-
-        // Precedence: per-call override, configured model, session model.
-        const requested =
-          params.model?.trim() ||
-          config.recognize.model.trim() ||
-          currentSessionModel(ctx);
-
-        if (!requested) {
-          return errorResult(
-            "No vision model configured.\n" +
-              "→ Choose one with /unipi:settings, or pass `model`.",
-          );
-        }
-
-        const resolved = resolveVisionModel(requested, registry);
-        if (typeof resolved === "string") return errorResult(resolved);
-
-        const image = loadImage(params.image, ctx.cwd ?? process.cwd());
-
-        const chatModel = findChatModel(registry, resolved);
-        const baseUrl = chatModel?.baseUrl;
-        if (!baseUrl) {
-          return errorResult(
-            `Could not determine the API endpoint for ${formatModelRef(resolved)}.`,
-          );
-        }
-
-        const apiKey = await resolveApiKey(registry, resolved.provider);
-        if (!apiKey) {
-          return errorResult(
-            `No API key for provider "${resolved.provider}".\n` +
-              "→ Sign in with /login, or set the provider's API key environment variable.",
-          );
-        }
-
-        const result = await recognizeImage({
-          image,
-          prompt: params.prompt?.trim() || "Describe this image in detail.",
-          systemPrompt: params.systemPrompt?.trim() || config.recognize.systemPrompt,
-          apiKey,
-          baseUrl,
-          api: chatModel?.api ?? "openai-completions",
-          modelId: resolved.id,
-          signal,
-        });
-
-        const origin = image.path ? ` (${image.path})` : "";
-
-        return {
-          content: [
-            {
-              type: "text" as const,
-              text: `${result.text}\n\n— analyzed with ${formatModelRef(resolved)}${origin}`,
-            },
-          ],
-          details: {
-            model: formatModelRef(resolved),
-            mimeType: image.mimeType,
-            source: image.source,
-            ...(image.path ? { path: image.path } : {}),
-          },
-        };
-      } catch (error) {
-        return errorResult(`Image recognition failed: ${messageOf(error)}`);
-      }
-    },
-  });
-}
-
-/** The session's current model as "provider/id", when discoverable. */
-function currentSessionModel(ctx: ExtensionContext): string {
-  const model = (ctx as unknown as { model?: { provider?: string; id?: string } }).model;
-  if (model?.provider && model?.id) {
-    return formatModelRef({ provider: model.provider, id: model.id });
-  }
-  return "";
-}

package/packages/input-shortcuts/src/clipboard.ts

@@ -1,119 +0,0 @@
-/**
- * Cross-platform clipboard read/write using child_process.
- * Detection order: xclip → xsel → pbcopy/pbpaste → clip/powershell.
- * Caches detected command on first use.
- */
-
-import { execSync } from "node:child_process";
-
-export interface ClipboardResult {
-  ok: boolean;
-  text?: string;
-  reason?: string;
-}
-
-type ClipboardTool = "xclip" | "xsel" | "pbcopy" | "clip" | "powershell" | null;
-
-let cachedTool: ClipboardTool | undefined; // undefined = not yet detected
-
-/**
- * Detect available clipboard command. Caches result.
- */
-export function detectClipboard(): ClipboardTool {
-  if (cachedTool !== undefined) return cachedTool;
-
-  const tools: Array<{ name: ClipboardTool; test: string }> = [
-    { name: "xclip", test: "xclip -selection clipboard -o" },
-    { name: "xsel", test: "xsel --clipboard --output" },
-    { name: "pbcopy", test: "pbpaste" },
-    { name: "clip", test: "echo test | clip" },
-    { name: "powershell", test: "powershell -command Get-Clipboard" },
-  ];
-
-  for (const tool of tools) {
-    try {
-      execSync(tool.test, { stdio: "ignore", timeout: 2000 });
-      cachedTool = tool.name;
-      return cachedTool;
-    } catch {
-      // Try next tool
-    }
-  }
-
-  cachedTool = null;
-  return null;
-}
-
-/**
- * Copy text to system clipboard.
- */
-export function copyToClipboard(text: string): ClipboardResult {
-  const tool = detectClipboard();
-  if (!tool) return { ok: false, reason: "clipboard unavailable" };
-
-  try {
-    switch (tool) {
-      case "xclip":
-        execSync("xclip -selection clipboard", { input: text, timeout: 2000 });
-        break;
-      case "xsel":
-        execSync("xsel --clipboard --input", { input: text, timeout: 2000 });
-        break;
-      case "pbcopy":
-        execSync("pbcopy", { input: text, timeout: 2000 });
-        break;
-      case "clip":
-        execSync("clip", { input: text, timeout: 2000 });
-        break;
-      case "powershell":
-        execSync(`powershell -command "Set-Clipboard -Value '${text.replace(/'/g, "''")}'"`, { timeout: 2000 });
-        break;
-    }
-    return { ok: true };
-  } catch {
-    return { ok: false, reason: "clipboard write failed" };
-  }
-}
-
-/**
- * Read text from system clipboard.
- */
-export function pasteFromClipboard(): ClipboardResult {
-  const tool = detectClipboard();
-  if (!tool) return { ok: false, reason: "clipboard unavailable" };
-
-  try {
-    let text: string;
-    switch (tool) {
-      case "xclip":
-        text = execSync("xclip -selection clipboard -o", { encoding: "utf-8", timeout: 2000 }).trimEnd();
-        break;
-      case "xsel":
-        text = execSync("xsel --clipboard --output", { encoding: "utf-8", timeout: 2000 }).trimEnd();
-        break;
-      case "pbcopy":
-        // pbcopy is write-only; use pbpaste for reading
-        text = execSync("pbpaste", { encoding: "utf-8", timeout: 2000 }).trimEnd();
-        break;
-      case "clip":
-        // clip is write-only on Windows; use powershell for reading
-        text = execSync("powershell -command Get-Clipboard", { encoding: "utf-8", timeout: 2000 }).trimEnd();
-        break;
-      case "powershell":
-        text = execSync("powershell -command Get-Clipboard", { encoding: "utf-8", timeout: 2000 }).trimEnd();
-        break;
-      default:
-        return { ok: false, reason: "clipboard unavailable" };
-    }
-    return { ok: true, text };
-  } catch {
-    return { ok: false, reason: "clipboard read failed" };
-  }
-}
-
-/**
- * Reset cached tool detection (for testing).
- */
-export function resetClipboardCache(): void {
-  cachedTool = undefined;
-}