@zetaloop/chappie 0.5.0 → 1.0.0

package/src/config.ts

@@ -1,20 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import * as z from "zod";
-
-const configSchema = z.object({
-	ask: z.boolean().optional(),
-	connect: z.string().min(1).optional(),
-	listen: z.union([z.boolean(), z.number().int().min(1).max(65535)]).optional(),
-});
-
-export async function readConfig(agentDir: string) {
-	let contents: string;
-	try {
-		contents = await readFile(join(agentDir, "chappie.json"), "utf8");
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
-		throw error;
-	}
-	return configSchema.parse(JSON.parse(contents));
-}

package/src/delivery.ts

@@ -1,54 +0,0 @@
-import type { ToolResultMessage } from "@earendil-works/pi-ai";
-import type { Source } from "./activity.ts";
-import {
-	contentWithImageReferences,
-	resourceDescriptors,
-} from "./resources.ts";
-
-export interface DeliveryRecord extends Source {
-	id: string;
-	sessionId: string;
-	cwd: string;
-	toolResults: ToolResultMessage[];
-	error?: string;
-}
-
-export function toolResultsContent(
-	toolResults: ToolResultMessage[],
-	sessionId: string,
-) {
-	return toolResults.flatMap((result) => [
-		{
-			type: "text" as const,
-			text: JSON.stringify({
-				toolCallId: result.toolCallId,
-				toolName: result.toolName,
-				isError: result.isError,
-			}),
-		},
-		...contentWithImageReferences(sessionId, result.content),
-		...resourceDescriptors(result.details).map((resource) => ({
-			type: "resource_link" as const,
-			uri: resource.uri,
-			name: resource.name,
-			mimeType: resource.mimeType,
-			size: resource.size,
-		})),
-	]);
-}
-
-export function deliveryContent(deliveries: DeliveryRecord[]) {
-	return deliveries.flatMap((delivery) => [
-		{
-			type: "text" as const,
-			text: JSON.stringify({
-				deferredResult: delivery.id,
-				requestId: delivery.requestId,
-				sessionId: delivery.sessionId,
-				cwd: delivery.cwd,
-				error: delivery.error,
-			}),
-		},
-		...toolResultsContent(delivery.toolResults, delivery.sessionId),
-	]);
-}

package/src/history.ts

@@ -1,136 +0,0 @@
-import type { SessionEntry } from "@earendil-works/pi-coding-agent";
-import * as z from "zod";
-import type { Activity, Source } from "./activity.ts";
-import { toolResultsContent } from "./delivery.ts";
-import type { ProviderOutput } from "./provider.ts";
-import { contentWithImageReferences, rememberImages } from "./resources.ts";
-
-export const historyInput = z.object({
-	limit: z
-		.number()
-		.int()
-		.min(1)
-		.default(20)
-		.describe("Maximum number of history entries"),
-	before: z
-		.string()
-		.min(1)
-		.optional()
-		.describe("Read entries before this entry ID"),
-	after: z
-		.string()
-		.min(1)
-		.optional()
-		.describe("Read entries after this entry ID, starting with the earliest"),
-	wait: z
-		.boolean()
-		.optional()
-		.describe(
-			"Wait up to 30 seconds for new entries when caught up; before reads return immediately",
-		),
-	observer: z
-		.boolean()
-		.optional()
-		.describe("Read work progress as an observer"),
-});
-
-export type HistoryRange = z.infer<typeof historyInput>;
-export type HistoryResult = ReturnType<typeof historyResult>;
-
-export const historyInstructions =
-	"When resuming work, read recent history to recover progress, then continue from the current request.";
-
-export function historyResult(
-	branch: SessionEntry[],
-	sessionId: string,
-	{ limit, before, after }: HistoryRange,
-) {
-	const start = after ? entryIndex(branch, after) + 1 : 0;
-	const end = before ? entryIndex(branch, before) : branch.length;
-	if (start > end) throw new Error("History after must precede before");
-	const entries = branch.slice(start, end).filter((entry) => {
-		switch (entry.type) {
-			case "message":
-				return (
-					entry.message.role !== "custom" ||
-					entry.message.customType !== "chappie.request"
-				);
-			case "custom_message":
-				return entry.customType !== "chappie.request";
-			case "custom":
-				return (
-					entry.customType === "chappie.notice" &&
-					(entry.data as Activity | undefined)?.event !== "history"
-				);
-			case "compaction":
-			case "branch_summary":
-				return true;
-			default:
-				return false;
-		}
-	});
-	const selected = after ? entries.slice(0, limit) : entries.slice(-limit);
-	const sources = new Map<string, Source>();
-	for (const entry of branch) {
-		if (entry.type !== "message" || entry.message.role !== "assistant")
-			continue;
-		const message = entry.message as ProviderOutput["message"];
-		if (!message.chappie) continue;
-		for (const block of message.content) {
-			if (block.type === "toolCall") sources.set(block.id, message.chappie);
-		}
-	}
-	return {
-		count: selected.length,
-		hasMore: entries.length > selected.length,
-		content: selected.flatMap((entry) =>
-			entryContent(entry, sessionId, sources),
-		),
-	};
-}
-
-function entryIndex(entries: SessionEntry[], id: string): number {
-	const index = entries.findIndex((entry) => entry.id === id);
-	if (index === -1)
-		throw new Error(`History entry ${id} is not on the current branch`);
-	return index;
-}
-
-function entryContent(
-	entry: SessionEntry,
-	sessionId: string,
-	sources: Map<string, Source>,
-): ReturnType<typeof toolResultsContent> {
-	const record: Record<string, unknown> = { ...entry };
-	const message = entry.type === "message" ? entry.message : entry;
-	if (!("content" in message)) {
-		return [{ type: "text", text: JSON.stringify(record) }];
-	}
-	const { content, ...metadata } = message;
-	if (entry.type === "message") {
-		const source =
-			entry.message.role === "toolResult"
-				? sources.get(entry.message.toolCallId)
-				: undefined;
-		record.message = { ...metadata, ...(source ? { chappie: source } : {}) };
-	} else delete record.content;
-	const header = { type: "text" as const, text: JSON.stringify(record) };
-	if (entry.type === "message" && entry.message.role === "toolResult") {
-		rememberImages(sessionId, entry.message.content);
-		return [header, ...toolResultsContent([entry.message], sessionId)];
-	}
-	const blocks =
-		typeof content === "string"
-			? [{ type: "text" as const, text: content }]
-			: content;
-	return [
-		header,
-		...blocks.flatMap((block): ReturnType<typeof toolResultsContent> => {
-			if (block.type === "text" || block.type === "image") {
-				rememberImages(sessionId, [block]);
-				return contentWithImageReferences(sessionId, [block]);
-			}
-			return [{ type: "text", text: JSON.stringify(block) }];
-		}),
-	];
-}

package/src/index.ts

@@ -1,42 +0,0 @@
-import {
-	type ExtensionAPI,
-	getAgentDir,
-} from "@earendil-works/pi-coding-agent";
-
-export default async function chappie(pi: ExtensionAPI): Promise<void> {
-	pi.registerFlag("chappie", {
-		description: "Serve Chappie over MCP",
-		type: "boolean",
-	});
-
-	if (process.argv.includes("--chappie")) {
-		try {
-			const { serveChappie } = await import("./stdio.ts");
-			await serveChappie();
-		} catch (error) {
-			console.error(error instanceof Error ? error.message : String(error));
-			process.exit(1);
-		}
-	}
-
-	const agentDir = getAgentDir();
-	const [
-		{ readConfig },
-		{ createChappieProvider },
-		{ LocalSession },
-		{ transfer },
-	] = await Promise.all([
-		import("./config.ts"),
-		import("./provider.ts"),
-		import("./session.ts"),
-		import("./transfer.ts"),
-	]);
-	const config = await readConfig(agentDir);
-	const session = new LocalSession(pi, agentDir, config.connect);
-	session.install();
-	pi.registerTool({
-		...transfer,
-		execute: (...args) => session.transfer(...args),
-	});
-	pi.registerProvider(createChappieProvider((output) => session.start(output)));
-}

package/src/instructions.md

@@ -1,17 +0,0 @@
-Chappie connects this ChatGPT conversation to Pi sessions on one or more devices. Resume work with init using the task's Pi sessionId, including in a new chat or branch. When only a project or session name is known, find its device/cwd/name in sessions, then call init. If the target is absent or ambiguous, ask the user to resolve it. Pi sessions appear while the chappie/chatgpt provider is selected.
-
-init sets this chat's default Pi session. An execution tool also establishes a default on first use: sessionId selects its target, or omitting it selects the first online session with no saved bindings. These sessions may already contain work. Once a default exists, another tool's sessionId selects only that call's target. Defaults survive broker restarts, and several chats can share one Pi session. When globalAgents is present, read and follow the instructions at globalAgents.path. Follow initialization.instructions for your participation in the current task. When executing work, read recent history to recover progress, then continue from the current request.
-
-The active model is this existing ChatGPT conversation. A Pi tool that starts another chappie/chatgpt agent has no ChatGPT conversation to attach to and will wait indefinitely. Subagents targeting another configured model keep that provider's normal behavior.
-
-Prefer ChatGPT's web search, connectors, and cloud tools for remote research and cloud-side work. Use Chappie for local files, processes, Pi extensions, and Pi user interfaces. Pi project-memory tools operate on their local stores; Pi context-reduction tools do not change this ChatGPT conversation.
-
-Respond promptly to new Pi user input with a substantive reply, interaction, or immediate action that makes the response apparent in Pi before continuing lengthy work. Address inputs received together in one response; an immediate answer or result serves as its own acknowledgment.
-
-When executing work, use chat for assistant messages in Pi, including progress, explanations, and completion results. Use read, bash, edit, write, and transfer directly. init.tools is a Pi tool catalog; tools returns full definitions for call. Invoke Chappie's MCP tools directly. Each call array is one native Pi batch; separate calls are separate Pi turns. For Pi interaction, call an installed interactive tool.
-
-transfer pairs files from ChatGPT with Pi destination paths in order. To copy between Pi sessions, use paths on the selected source session and to: { sessionId, paths } for the destination. Each side resolves paths in its own working directory. Omit files and to to return resource links for Pi paths or chappie:// image references. Relative paths use the Pi working directory; overwrite: true replaces existing targets. The host may request confirmation when retrieving exported bytes.
-
-Tool results identify the executing Pi sessionId and cwd. A shell command can access another directory without changing its Pi session. structuredContent.text includes tool output, new Pi input, webAnswer, and deferred results; images and resources are native content blocks. ChatGPT truncates tool responses exceeding 10,000 tokens. Continue from received results rather than repeating work. Host deadlines include queueing and execution; use local persistent processes for longer work.
-
-Use history to read the current Pi branch with entry IDs and timestamps. History defaults to the last 20 entries; before pages backward and after pages forward. Use after with wait: true to follow progress: available entries return immediately, otherwise the call waits up to 30 seconds. An empty result means no new entries. Set observer: true when reading as an observer. Read the work's completion message to form the final reply. History returns saved contents separately from new Pi input.