@nmzpy/pi-ember-stack 0.1.1 → 0.1.2

package/plugins/devin-auth/src/stream.ts

@@ -0,0 +1,341 @@
+/**
+ * pi `streamSimple` implementation for the Devin/Cognition provider.
+ *
+ * Calls the cloud-direct gRPC streaming layer (`streamChatEvents`) and
+ * translates the resulting `CloudChatEvent` stream into pi's
+ * `AssistantMessageEventStream` events.
+ *
+ * The async-IIFE pattern is the standard pi `streamSimple` shape: the
+ * function returns a `AssistantMessageEventStream` synchronously and drives
+ * the upstream async iterator inside an IIFE, pushing events as they
+ * arrive.
+ */
+import {
+    type Api,
+    type AssistantMessage,
+    type AssistantMessageEventStream,
+    type Context,
+    type Model,
+    type SimpleStreamOptions,
+    calculateCost,
+    createAssistantMessageEventStream,
+} from '@earendil-works/pi-ai';
+import { streamChatEvents, type CloudChatEvent } from './cloud-direct/index.js';
+import { mapContextToChat } from './context-map.js';
+
+/**
+ * Stream a Devin/Cognition chat completion into pi's assistant-message
+ * event stream.
+ *
+ * @param model     pi model descriptor (id, api, provider, cost, ...).
+ * @param context   pi conversation context (systemPrompt, messages, tools).
+ * @param options   streaming options (apiKey, maxTokens, signal, ...).
+ * @returns an {@link AssistantMessageEventStream} that receives events
+ *          as the upstream gRPC stream progresses.
+ */
+export function streamDevin(
+    model: Model<Api>,
+    context: Context,
+    options?: SimpleStreamOptions,
+): AssistantMessageEventStream {
+    const stream = createAssistantMessageEventStream();
+
+    // Drive the upstream async iterator inside an IIFE so the returned
+    // stream is populated asynchronously.
+    void (async () => {
+        const output: AssistantMessage = {
+            role: 'assistant',
+            content: [],
+            api: model.api,
+            provider: model.provider,
+            model: model.id,
+            usage: {
+                input: 0,
+                output: 0,
+                cacheRead: 0,
+                cacheWrite: 0,
+                totalTokens: 0,
+                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+            },
+            stopReason: 'stop',
+            timestamp: Date.now(),
+        };
+
+        // Block-tracking state. Cognition's wire format has no
+        // `tool_call_end` event, so the end of a tool call is implicit:
+        // a new `tool_call_start` or stream `finish` closes the prior call.
+        let textBlockOpen = false;
+        let thinkingBlockOpen = false;
+        let currentToolCallIndex = -1;
+        let partialJson = '';
+        let currentToolCallId = '';
+        let currentToolCallName = '';
+
+        try {
+            const apiKey = options?.apiKey;
+            if (!apiKey) throw new Error('No Devin API key. Run /login devin');
+
+            const { messages, tools } = mapContextToChat(context);
+            stream.push({ type: 'start', partial: output });
+
+            for await (const ev of streamChatEvents({
+                apiKey,
+                modelUid: model.id,
+                messages,
+                tools: tools.length > 0 ? tools : undefined,
+                signal: options?.signal,
+                completionOpts: {
+                    maxOutputTokens: options?.maxTokens,
+                },
+            })) {
+                handleEvent(ev);
+            }
+
+            // Safety: close any still-open blocks at stream end.
+            closeTextBlock();
+            closeThinkingBlock();
+            if (currentToolCallIndex >= 0) {
+                closeToolCall(
+                    stream,
+                    output,
+                    currentToolCallIndex,
+                    partialJson,
+                    currentToolCallId,
+                    currentToolCallName,
+                );
+                currentToolCallIndex = -1;
+            }
+
+            stream.push({
+                type: 'done',
+                reason: output.stopReason as 'stop' | 'length' | 'toolUse',
+                message: output,
+            });
+            stream.end();
+        } catch (error) {
+            output.stopReason = options?.signal?.aborted ? 'aborted' : 'error';
+            output.errorMessage = error instanceof Error ? error.message : String(error);
+            stream.push({
+                type: 'error',
+                reason: output.stopReason as 'aborted' | 'error',
+                error: output,
+            });
+            stream.end();
+        }
+
+        /**
+         * Dispatch a single {@link CloudChatEvent} to the appropriate
+         * pi event(s), mutating `output` and the block-tracking state.
+         */
+        function handleEvent(ev: CloudChatEvent): void {
+            switch (ev.kind) {
+                case 'text': {
+                    // A text delta ends any open thinking block.
+                    closeThinkingBlock();
+                    if (!textBlockOpen) {
+                        output.content.push({ type: 'text', text: '' });
+                        stream.push({
+                            type: 'text_start',
+                            contentIndex: output.content.length - 1,
+                            partial: output,
+                        });
+                        textBlockOpen = true;
+                    }
+                    const idx = output.content.length - 1;
+                    const block = output.content[idx];
+                    if (block.type === 'text') {
+                        block.text += ev.text;
+                        stream.push({
+                            type: 'text_delta',
+                            contentIndex: idx,
+                            delta: ev.text,
+                            partial: output,
+                        });
+                    }
+                    break;
+                }
+
+                case 'reasoning': {
+                    // A reasoning delta ends any open text block.
+                    closeTextBlock();
+                    if (!thinkingBlockOpen) {
+                        output.content.push({ type: 'thinking', thinking: '' });
+                        stream.push({
+                            type: 'thinking_start',
+                            contentIndex: output.content.length - 1,
+                            partial: output,
+                        });
+                        thinkingBlockOpen = true;
+                    }
+                    const idx = output.content.length - 1;
+                    const block = output.content[idx];
+                    if (block.type === 'thinking') {
+                        block.thinking += ev.text;
+                        stream.push({
+                            type: 'thinking_delta',
+                            contentIndex: idx,
+                            delta: ev.text,
+                            partial: output,
+                        });
+                    }
+                    break;
+                }
+
+                case 'tool_call_start': {
+                    // A new tool call ends any open text/thinking block,
+                    // and implicitly closes the previous tool call.
+                    closeTextBlock();
+                    closeThinkingBlock();
+                    if (currentToolCallIndex >= 0) {
+                        closeToolCall(
+                            stream,
+                            output,
+                            currentToolCallIndex,
+                            partialJson,
+                            currentToolCallId,
+                            currentToolCallName,
+                        );
+                    }
+                    currentToolCallId = ev.id;
+                    currentToolCallName = ev.name;
+                    partialJson = '';
+                    output.content.push({
+                        type: 'toolCall',
+                        id: ev.id,
+                        name: ev.name,
+                        arguments: {},
+                    });
+                    currentToolCallIndex = output.content.length - 1;
+                    stream.push({
+                        type: 'toolcall_start',
+                        contentIndex: currentToolCallIndex,
+                        partial: output,
+                    });
+                    break;
+                }
+
+                case 'tool_call_args': {
+                    // Defensive: args without a preceding start should not
+                    // happen on Cognition's wire format — ignore them.
+                    if (currentToolCallIndex < 0) break;
+                    partialJson += ev.argsDelta;
+                    const block = output.content[currentToolCallIndex];
+                    if (block.type === 'toolCall') {
+                        try {
+                            block.arguments = JSON.parse(partialJson);
+                        } catch {
+                            // Incomplete JSON — keep accumulating deltas.
+                        }
+                    }
+                    stream.push({
+                        type: 'toolcall_delta',
+                        contentIndex: currentToolCallIndex,
+                        delta: ev.argsDelta,
+                        partial: output,
+                    });
+                    break;
+                }
+
+                case 'finish': {
+                    closeTextBlock();
+                    closeThinkingBlock();
+                    if (currentToolCallIndex >= 0) {
+                        closeToolCall(
+                            stream,
+                            output,
+                            currentToolCallIndex,
+                            partialJson,
+                            currentToolCallId,
+                            currentToolCallName,
+                        );
+                        currentToolCallIndex = -1;
+                    }
+                    output.stopReason =
+                        ev.reason === 'tool_calls'
+                            ? 'toolUse'
+                            : ev.reason === 'length'
+                              ? 'length'
+                              : 'stop';
+                    break;
+                }
+
+                case 'usage': {
+                    output.usage.input = ev.promptTokens ?? 0;
+                    output.usage.output = ev.completionTokens ?? 0;
+                    output.usage.cacheRead = ev.cachedInputTokens ?? 0;
+                    output.usage.cacheWrite = ev.cacheCreationInputTokens ?? 0;
+                    output.usage.totalTokens =
+                        ev.totalTokens ?? output.usage.input + output.usage.output;
+                    // calculateCost mutates output.usage.cost in place.
+                    calculateCost(model, output.usage);
+                    break;
+                }
+            }
+        }
+
+        /** Close the open text block, if any, emitting `text_end`. */
+        function closeTextBlock(): void {
+            if (!textBlockOpen) return;
+            const idx = output.content.length - 1;
+            const block = output.content[idx];
+            if (block.type === 'text') {
+                stream.push({
+                    type: 'text_end',
+                    contentIndex: idx,
+                    content: block.text,
+                    partial: output,
+                });
+            }
+            textBlockOpen = false;
+        }
+
+        /** Close the open thinking block, if any, emitting `thinking_end`. */
+        function closeThinkingBlock(): void {
+            if (!thinkingBlockOpen) return;
+            const idx = output.content.length - 1;
+            const block = output.content[idx];
+            if (block.type === 'thinking') {
+                stream.push({
+                    type: 'thinking_end',
+                    contentIndex: idx,
+                    content: block.thinking,
+                    partial: output,
+                });
+            }
+            thinkingBlockOpen = false;
+        }
+    })();
+
+    return stream;
+}
+
+/**
+ * Close a tool-call block: attempt a final JSON parse of the accumulated
+ * args delta and emit `toolcall_end` with the resolved {@link ToolCall}.
+ *
+ * Defined at module scope so it is hoisted and usable from the IIFE
+ * closure without forward-reference concerns.
+ */
+function closeToolCall(
+    stream: AssistantMessageEventStream,
+    output: AssistantMessage,
+    index: number,
+    partialJson: string,
+    id: string,
+    name: string,
+): void {
+    const block = output.content[index];
+    if (block.type !== 'toolCall') return;
+    // One last parse attempt in case the final delta completed the JSON.
+    try {
+        block.arguments = JSON.parse(partialJson);
+    } catch {
+        // Leave arguments as the last successfully-parsed value (or `{}`).
+    }
+    stream.push({
+        type: 'toolcall_end',
+        contentIndex: index,
+        toolCall: { type: 'toolCall', id, name, arguments: block.arguments },
+        partial: output,
+    });
+}

package/{src/pi-ember-stack.ts → plugins/ember/index.ts}

@@ -52,8 +52,8 @@ const FULL_TOOLS = ["read", "bash", "edit", "write", "grep", "find", "ls", "ques
 
 const SOURCE_ROOT = path.dirname(fileURLToPath(import.meta.url));
 const SUBAGENT_FILES: Record<string, string> = {
-	coder: path.join(SOURCE_ROOT, "subagent", "agents", "coder.md"),
-	architect: path.join(SOURCE_ROOT, "subagent", "agents", "architect.md"),
+	coder: path.join(SOURCE_ROOT, "..", "subagent", "agents", "coder.md"),
+	architect: path.join(SOURCE_ROOT, "..", "subagent", "agents", "architect.md"),
 };
 
 interface ModeConfig {

package/plugins/index.ts

@@ -0,0 +1,138 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import devinAuthPlugin from "./devin-auth/extensions/index.ts";
+import emberPlugin from "./ember/index.ts";
+import subagentPlugin from "./subagent/extensions/index.ts";
+
+type PluginId = "ember" | "subagent" | "devin-auth";
+type StackPlugin = {
+	id: PluginId;
+	description: string;
+	extension: (pi: ExtensionAPI) => void | Promise<void>;
+};
+
+type StackPluginConfig = {
+	plugins?: unknown;
+};
+
+const CONFIG_RELATIVE_PATH = path.join(".pi", "ember-stack.json");
+const DEFAULT_PLUGIN_IDS: readonly PluginId[] = [
+	"ember",
+	"subagent",
+	"devin-auth",
+];
+
+const PLUGINS: readonly StackPlugin[] = [
+	{
+		id: "ember",
+		description: "Ember modes, questionnaire, footer, and compact edit rendering",
+		extension: emberPlugin,
+	},
+	{
+		id: "subagent",
+		description: "Bundled subagent tool and agent definitions",
+		extension: subagentPlugin,
+	},
+	{
+		id: "devin-auth",
+		description: "Devin OAuth provider, model catalog, and streaming transport",
+		extension: devinAuthPlugin,
+	},
+];
+
+function isPluginId(value: unknown): value is PluginId {
+	return typeof value === "string" && PLUGINS.some((plugin) => plugin.id === value);
+}
+
+function getConfigPath(cwd: string): string {
+	return path.join(cwd, CONFIG_RELATIVE_PATH);
+}
+
+function readEnabledPlugins(cwd: string): Set<PluginId> {
+	const configPath = getConfigPath(cwd);
+	if (!fs.existsSync(configPath)) return new Set(DEFAULT_PLUGIN_IDS);
+
+	let config: StackPluginConfig;
+	try {
+		config = JSON.parse(fs.readFileSync(configPath, "utf-8")) as StackPluginConfig;
+	} catch (error) {
+		throw new Error(
+			`Invalid ${CONFIG_RELATIVE_PATH}: ${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
+
+	if (!Array.isArray(config.plugins)) {
+		throw new Error(
+			`${CONFIG_RELATIVE_PATH} must contain a plugins array with known plugin IDs.`,
+		);
+	}
+
+	const unknownPlugin = config.plugins.find((pluginId) => !isPluginId(pluginId));
+	if (unknownPlugin !== undefined) {
+		throw new Error(
+			`Unknown pi-ember-stack plugin ${String(unknownPlugin)} in ${CONFIG_RELATIVE_PATH}.`,
+		);
+	}
+
+	return new Set(config.plugins as PluginId[]);
+}
+
+function writeEnabledPlugins(cwd: string, enabledPlugins: Set<PluginId>): void {
+	const configPath = getConfigPath(cwd);
+	fs.mkdirSync(path.dirname(configPath), { recursive: true });
+	fs.writeFileSync(
+		configPath,
+		`${JSON.stringify({ plugins: PLUGINS.filter((plugin) => enabledPlugins.has(plugin.id)).map((plugin) => plugin.id) }, null, 2)}\n`,
+		"utf-8",
+	);
+}
+
+function formatPluginChoice(plugin: StackPlugin, enabledPlugins: Set<PluginId>): string {
+	return `${enabledPlugins.has(plugin.id) ? "[on]" : "[off]"} ${plugin.id} — ${plugin.description}`;
+}
+
+function registerPluginCommand(
+	pi: ExtensionAPI,
+	cwd: string,
+	enabledPlugins: Set<PluginId>,
+): void {
+	pi.registerCommand("stack-plugins", {
+		description: "Show or toggle pi-ember-stack plugins",
+		handler: async (_args, ctx) => {
+			if (!ctx.hasUI) {
+				ctx.ui.notify(`Enabled pi-ember-stack plugins: ${[...enabledPlugins].join(", ")}`);
+				return;
+			}
+
+			const choices = PLUGINS.map((plugin) => formatPluginChoice(plugin, enabledPlugins));
+			const selected = await ctx.ui.select("Plugin to toggle", choices);
+			if (!selected) return;
+
+			const selectedIndex = choices.indexOf(selected);
+			const plugin = PLUGINS[selectedIndex];
+			if (!plugin) return;
+
+			if (enabledPlugins.has(plugin.id)) {
+				enabledPlugins.delete(plugin.id);
+			} else {
+				enabledPlugins.add(plugin.id);
+			}
+			writeEnabledPlugins(cwd, enabledPlugins);
+			ctx.ui.notify(
+				`${plugin.id} ${enabledPlugins.has(plugin.id) ? "enabled" : "disabled"}. Restart pi to apply the change.`,
+			);
+		},
+	});
+}
+
+export default async function piEmberStackPlugin(pi: ExtensionAPI): Promise<void> {
+	const cwd = process.cwd();
+	const enabledPlugins = readEnabledPlugins(cwd);
+	for (const plugin of PLUGINS) {
+		if (!enabledPlugins.has(plugin.id)) continue;
+		await plugin.extension(pi);
+	}
+	registerPluginCommand(pi, cwd, enabledPlugins);
+}

package/{src → plugins}/subagent/extensions/model.ts

@@ -1,96 +1,96 @@
-/**
- * Shared model resolution for pi-subagent.
- *
- * Provides a single canonical resolveModel() used by both the tool handler
- * (index.ts) and the event-driven service path (service.ts), ensuring
- * consistent error reporting across all sub-agent invocation paths.
- *
- * Queries the parent ModelRegistry first (catches custom-configured models
- * with overridden base URLs, headers, compatibility settings). Falls back
- * to the built-in registry for unconfigured models.
- * For unqualified names (no provider prefix), known naming conventions
- * are tried before assuming Anthropic.
- */
-
-import type { Model } from "@earendil-works/pi-ai";
-import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
-
-type BuiltInModelResolver = (provider: string, id: string) => Model<any> | undefined;
-
-interface ModelModule {
-	getModel: BuiltInModelResolver;
-}
-
-// Pi 0.80 exposes getModel from /compat; 0.79 exported it from the main entry.
-const { getModel } = (await import("@earendil-works/pi-ai/compat").catch(
-	() => import("@earendil-works/pi-ai"),
-)) as ModelModule;
-
-export interface ResolvedModel {
-	model: Model<any> | null;
-	attempted: string[];
-}
-
-/** Known provider prefixes for unqualified model names. */
-const KNOWN_PROVIDERS: [string, RegExp][] = [
-	["openai", /^gpt-/i],
-	["anthropic", /^claude-/i],
-	["google", /^gemini-/i],
-	["cohere", /^command-/i],
-	["deepseek", /^(deepseek-|ds-)/i],
-	["mistral", /^mistral-/i],
-	["groq", /^(groq-|llama-)/i],
-];
-
-function tryGetModel(
-	provider: string,
-	id: string,
-	modelRegistry?: ModelRegistry,
-): Model<any> | null {
-	// Query parent ModelRegistry first — it includes custom-configured models
-	// (overridden base URLs, headers, compatibility settings, per-model overrides).
-	// Fall back to built-in registry for unconfigured models.
-	if (modelRegistry) {
-		const found = modelRegistry.find(provider as any, id as any) ?? null;
-		if (found) return found;
-	}
-	const builtIn = getModel(provider as any, id as any) ?? null;
-	if (builtIn) return builtIn;
-	return null;
-}
-
-export function resolveModel(
-	modelName: string | undefined,
-	parentModel: Model<any> | undefined,
-	modelRegistry?: ModelRegistry,
-): ResolvedModel {
-	const attempted: string[] = [];
-	if (modelName) {
-		const idx = modelName.indexOf("/");
-		if (idx > 0) {
-			// Provider-qualified: "openai/gpt-4o" or "openrouter/anthropic/claude-3.5"
-			const provider = modelName.slice(0, idx);
-			const id = modelName.slice(idx + 1);
-			attempted.push(modelName);
-			const found = tryGetModel(provider, id, modelRegistry);
-			if (found) return { model: found, attempted };
-		} else {
-			// Unqualified: try known providers by naming convention
-			for (const [provider, pattern] of KNOWN_PROVIDERS) {
-				if (pattern.test(modelName)) {
-					attempted.push(`${provider}/${modelName}`);
-					const found = tryGetModel(provider, modelName, modelRegistry);
-					if (found) return { model: found, attempted };
-				}
-			}
-			// Fall back to Anthropic shorthand (backward compat)
-			attempted.push(`anthropic/${modelName}`);
-			const found = tryGetModel("anthropic", modelName, modelRegistry);
-			if (found) return { model: found, attempted };
-		}
-	} else if (parentModel) {
-		attempted.push(`${parentModel.provider}/${parentModel.id}`);
-		return { model: parentModel, attempted };
-	}
-	return { model: null, attempted };
-}
+/**
+ * Shared model resolution for pi-subagent.
+ *
+ * Provides a single canonical resolveModel() used by both the tool handler
+ * (index.ts) and the event-driven service path (service.ts), ensuring
+ * consistent error reporting across all sub-agent invocation paths.
+ *
+ * Queries the parent ModelRegistry first (catches custom-configured models
+ * with overridden base URLs, headers, compatibility settings). Falls back
+ * to the built-in registry for unconfigured models.
+ * For unqualified names (no provider prefix), known naming conventions
+ * are tried before assuming Anthropic.
+ */
+
+import type { Model } from "@earendil-works/pi-ai";
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+
+type BuiltInModelResolver = (provider: string, id: string) => Model<any> | undefined;
+
+interface ModelModule {
+	getModel: BuiltInModelResolver;
+}
+
+// Pi 0.80 exposes getModel from /compat; 0.79 exported it from the main entry.
+const { getModel } = (await import("@earendil-works/pi-ai/compat").catch(
+	() => import("@earendil-works/pi-ai"),
+)) as ModelModule;
+
+export interface ResolvedModel {
+	model: Model<any> | null;
+	attempted: string[];
+}
+
+/** Known provider prefixes for unqualified model names. */
+const KNOWN_PROVIDERS: [string, RegExp][] = [
+	["openai", /^gpt-/i],
+	["anthropic", /^claude-/i],
+	["google", /^gemini-/i],
+	["cohere", /^command-/i],
+	["deepseek", /^(deepseek-|ds-)/i],
+	["mistral", /^mistral-/i],
+	["groq", /^(groq-|llama-)/i],
+];
+
+function tryGetModel(
+	provider: string,
+	id: string,
+	modelRegistry?: ModelRegistry,
+): Model<any> | null {
+	// Query parent ModelRegistry first — it includes custom-configured models
+	// (overridden base URLs, headers, compatibility settings, per-model overrides).
+	// Fall back to built-in registry for unconfigured models.
+	if (modelRegistry) {
+		const found = modelRegistry.find(provider as any, id as any) ?? null;
+		if (found) return found;
+	}
+	const builtIn = getModel(provider as any, id as any) ?? null;
+	if (builtIn) return builtIn;
+	return null;
+}
+
+export function resolveModel(
+	modelName: string | undefined,
+	parentModel: Model<any> | undefined,
+	modelRegistry?: ModelRegistry,
+): ResolvedModel {
+	const attempted: string[] = [];
+	if (modelName) {
+		const idx = modelName.indexOf("/");
+		if (idx > 0) {
+			// Provider-qualified: "openai/gpt-4o" or "openrouter/anthropic/claude-3.5"
+			const provider = modelName.slice(0, idx);
+			const id = modelName.slice(idx + 1);
+			attempted.push(modelName);
+			const found = tryGetModel(provider, id, modelRegistry);
+			if (found) return { model: found, attempted };
+		} else {
+			// Unqualified: try known providers by naming convention
+			for (const [provider, pattern] of KNOWN_PROVIDERS) {
+				if (pattern.test(modelName)) {
+					attempted.push(`${provider}/${modelName}`);
+					const found = tryGetModel(provider, modelName, modelRegistry);
+					if (found) return { model: found, attempted };
+				}
+			}
+			// Fall back to Anthropic shorthand (backward compat)
+			attempted.push(`anthropic/${modelName}`);
+			const found = tryGetModel("anthropic", modelName, modelRegistry);
+			if (found) return { model: found, attempted };
+		}
+	} else if (parentModel) {
+		attempted.push(`${parentModel.provider}/${parentModel.id}`);
+		return { model: parentModel, attempted };
+	}
+	return { model: null, attempted };
+}