@zetaloop/chappie 0.5.0 → 1.0.0

package/dist/instructions.md

@@ -0,0 +1,13 @@
+Chappie connects this conversation to coding-agent sessions across devices. Native tools run on the selected session's device, using its working directory.
+
+Select the intended session with init. Resume existing work with the task's sessionId, including from another chat or branch. Use sessions to identify the target by agent, device, directory, or name when its ID is unknown.
+
+init sets this conversation's default target. A sessionId on another tool selects that operation's target. Read the file at globalAgents.path when returned, and follow initialization.instructions for participation in the task.
+
+Read recent history to recover progress. Use tools to obtain native definitions before constructing call arguments.
+
+Use chat for progress, explanations, and completion in the selected session. Use transfer to exchange files and images with ChatGPT or another session. For questions in the agent interface, call its installed interactive tool.
+
+Address new local user input delivered with results. Check delivered results before repeating interrupted operations. Use the session's persistent process facilities for long-running commands and read their saved output as needed.
+
+ChatGPT removes the middle of tool responses exceeding 10,000 tokens. Use history pagination or limit native tool output when needed.

package/dist/omp.js

@@ -0,0 +1,240 @@
+import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+import {
+  journalHistory
+} from "./chunk-OWAAWZNT.js";
+import {
+  ProviderOutput,
+  Session,
+  createMessage
+} from "./chunk-5CKVVDZ2.js";
+import {
+  localTools
+} from "./chunk-DM523QRR.js";
+import {
+  ipcEndpoint
+} from "./chunk-EIPDEA3I.js";
+import "./chunk-GX4JWLHH.js";
+import {
+  getDirectory,
+  readConfig,
+  toJSONSchema
+} from "./chunk-GWYP7B66.js";
+import "./chunk-UOFCCHBS.js";
+
+// src/omp.ts
+import { access } from "node:fs/promises";
+import { hostname } from "node:os";
+import { resolve } from "node:path";
+import { createAssistantMessageEventStream } from "@oh-my-pi/pi-ai/utils/event-stream";
+import { toolWireSchema } from "@oh-my-pi/pi-ai/utils/schema/wire";
+import { getAgentDir } from "@oh-my-pi/pi-utils";
+async function chappie(omp) {
+  const config = await readConfig();
+  let context;
+  let inputCursor = null;
+  let manager;
+  let unsubscribe;
+  const current = () => {
+    if (!context) throw new Error("Session has not started");
+    return context;
+  };
+  const host = {
+    describe() {
+      const ctx = current();
+      const name = ctx.sessionManager.getSessionName();
+      return {
+        id: ctx.sessionManager.getSessionId(),
+        agent: "omp",
+        cwd: ctx.cwd,
+        device: hostname(),
+        ...ctx.model ? { model: `${ctx.model.provider}/${ctx.model.id}` } : {},
+        ...name ? { name } : {}
+      };
+    },
+    active: () => context?.model?.provider === "chappie",
+    isIdle: () => current().isIdle(),
+    async inspect() {
+      const active = new Set(omp.getActiveTools());
+      const path = resolve(getAgentDir(), "AGENTS.md");
+      let globalAgents;
+      try {
+        await access(path);
+        globalAgents = { path };
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+      return {
+        tools: omp.getAllTools().filter((tool) => active.has(tool.name)).map((tool) => ({ ...tool, parameters: toolWireSchema(tool) })),
+        skills: omp.getCommands().filter((command) => command.source === "skill"),
+        ...globalAgents ? { globalAgents } : {}
+      };
+    },
+    async history(range) {
+      const ctx = current();
+      return journalHistory(
+        ctx.sessionManager.getBranch(),
+        ctx.sessionManager.getSessionId(),
+        range
+      );
+    },
+    inputs() {
+      const store = current().sessionManager;
+      const leafId = store.getLeafId();
+      if (leafId === inputCursor) return [];
+      const entries = [];
+      let entry = store.getLeafEntry();
+      while (entry && entry.id !== inputCursor) {
+        entries.push(entry);
+        entry = entry.parentId ? store.getEntry(entry.parentId) : void 0;
+      }
+      const changedBranch = inputCursor !== null && !entry;
+      inputCursor = leafId;
+      if (changedBranch) {
+        session.resetInputs();
+        return [];
+      }
+      const inputs = [];
+      for (const entry2 of entries.reverse()) {
+        if (entry2.type !== "message" || entry2.message.role !== "user") continue;
+        const message = entry2.message;
+        inputs.push({ id: entry2.id, sessionId: store.getSessionId(), message });
+      }
+      return inputs;
+    },
+    resetInputs() {
+      inputCursor = context?.sessionManager.getLeafId() ?? null;
+    },
+    wake() {
+      omp.sendMessage(
+        { customType: "chappie.request", content: "", display: false },
+        { triggerTurn: true, deliverAs: "nextTurn" }
+      );
+    },
+    abort: () => current().abort(),
+    notify(message, type, activity) {
+      omp.appendEntry("chappie.notice", { message, type, ...activity });
+      context?.ui.notify(message, type);
+    }
+  };
+  const session = new Session(host, config);
+  const tools = localTools(session);
+  const names = new Set(tools.map((tool) => tool.name));
+  async function updateTools() {
+    const desired = session.active ? ["transfer"] : session.localTools ? [...names] : [];
+    const active = omp.getActiveTools();
+    const enabled = active.filter((name) => names.has(name));
+    if (enabled.length === desired.length && enabled.every((name) => desired.includes(name)))
+      return;
+    await omp.setActiveTools([
+      ...active.filter((name) => !names.has(name)),
+      ...desired
+    ]);
+  }
+  async function update(ctx) {
+    context = ctx;
+    if (manager !== ctx.sessionManager) {
+      unsubscribe?.();
+      manager = ctx.sessionManager;
+      const store = manager;
+      const append = store.appendModelChange;
+      const record = function(...args) {
+        const result = append.apply(this, args);
+        if (session.update()) void updateTools();
+        return result;
+      };
+      store.appendModelChange = record;
+      const renamed = store.onSessionNameChanged(() => session.update());
+      unsubscribe = () => {
+        renamed();
+        if (store.appendModelChange === record)
+          store.appendModelChange = append;
+      };
+    }
+    if (session.update()) await updateTools();
+  }
+  omp.on("session_start", (_event, ctx) => update(ctx));
+  omp.on("session_switch", (_event, ctx) => update(ctx));
+  omp.on("session_branch", (_event, ctx) => update(ctx));
+  omp.on("session_tree", async (_event, ctx) => {
+    await update(ctx);
+    session.resetInputs();
+    session.historyChanged();
+  });
+  omp.on("context", (event) => ({
+    messages: host.active() ? [] : event.messages.filter(
+      (message) => message.role !== "custom" || message.customType !== "chappie.request"
+    )
+  }));
+  omp.on("message_start", (_event, ctx) => {
+    context = ctx;
+    session.historyChanged();
+  });
+  omp.on("message_end", (_event, ctx) => {
+    context = ctx;
+    session.historyChanged();
+  });
+  omp.on("session_compact", (_event, ctx) => {
+    context = ctx;
+    session.historyChanged();
+  });
+  omp.on("turn_end", (event, ctx) => {
+    context = ctx;
+    session.complete(event.message, event.toolResults);
+  });
+  omp.on("agent_end", async (_event, ctx) => {
+    context = ctx;
+    await session.settled();
+  });
+  omp.on("session_shutdown", () => {
+    unsubscribe?.();
+    session.close();
+  });
+  for (const tool of tools) {
+    omp.registerTool({
+      name: tool.name,
+      label: tool.name,
+      description: tool.description,
+      parameters: toJSONSchema(tool.parameters),
+      async execute(_id, args, signal, update2) {
+        const result = await tool.execute(
+          args,
+          signal,
+          (result2) => update2?.({ ...result2, details: result2.details })
+        );
+        return { ...result, details: result.details };
+      }
+    });
+  }
+  const provider = {
+    api: "chappie",
+    baseUrl: config.connect ?? ipcEndpoint(getDirectory()),
+    apiKey: "chappie",
+    models: [
+      {
+        id: "chatgpt",
+        name: "ChatGPT",
+        reasoning: false,
+        input: ["text", "image"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 1e9,
+        maxTokens: 1e9
+      }
+    ],
+    streamSimple(model, context2, options) {
+      const stream = createAssistantMessageEventStream();
+      const output = new ProviderOutput(
+        createMessage(model, "stop"),
+        stream,
+        options?.signal
+      );
+      queueMicrotask(() => {
+        void (options?.codexCompaction ? session.generate(output, { kind: "compaction", input: context2 }) : session.start(output)).catch((error) => output.fail(error));
+      });
+      return stream;
+    }
+  };
+  omp.registerProvider("chappie", provider);
+}
+export {
+  chappie as default
+};