@heyhuynhgiabuu/pi-task 0.1.0

package/dist/policy.d.ts

@@ -0,0 +1,3 @@
+/** Minimal shared tool-policy helpers for task agent frontmatter. */
+export declare const XAI_SIDE_TOOL_NAMES: readonly ["xai_generate_text", "xai_multi_agent", "xai_web_search", "xai_x_search", "xai_code_execution", "xai_generate_image", "xai_analyze_image", "xai_deep_research", "xai_critique"];
+export declare function parseMergedDisallowedTools(raw?: string): string[];

package/dist/policy.js

@@ -0,0 +1,35 @@
+/** Minimal shared tool-policy helpers for task agent frontmatter. */
+export const XAI_SIDE_TOOL_NAMES = [
+    "xai_generate_text",
+    "xai_multi_agent",
+    "xai_web_search",
+    "xai_x_search",
+    "xai_code_execution",
+    "xai_generate_image",
+    "xai_analyze_image",
+    "xai_deep_research",
+    "xai_critique",
+];
+function xaiSideToolsEnabled() {
+    const raw = (process.env.PI_XAI_SIDE_TOOLS ?? "").trim().toLowerCase();
+    return raw === "1" || raw === "true" || raw === "yes";
+}
+export function parseMergedDisallowedTools(raw) {
+    const result = new Set();
+    if (!xaiSideToolsEnabled()) {
+        for (const tool of XAI_SIDE_TOOL_NAMES)
+            result.add(tool);
+    }
+    for (const token of (raw ?? "").split(",")) {
+        const value = token.trim();
+        if (!value)
+            continue;
+        if (value === "xai") {
+            for (const tool of XAI_SIDE_TOOL_NAMES)
+                result.add(tool);
+            continue;
+        }
+        result.add(value);
+    }
+    return [...result];
+}

package/dist/session-text.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Read assistant text from pi JSONL session directories (task / harness).
+ */
+/**
+ * Last non-empty assistant message across all .jsonl files in sessionDir.
+ */
+export declare function getLastAssistantTextFromSessionDir(sessionDir: string): string;

package/dist/session-text.js

@@ -0,0 +1,50 @@
+/**
+ * Read assistant text from pi JSONL session directories (task / harness).
+ */
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+function extractText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((b) => b?.type === "text")
+        .map((b) => b.text ?? "")
+        .join("\n")
+        .trim();
+}
+/**
+ * Last non-empty assistant message across all .jsonl files in sessionDir.
+ */
+export function getLastAssistantTextFromSessionDir(sessionDir) {
+    if (!existsSync(sessionDir))
+        return "";
+    const files = readdirSync(sessionDir)
+        .filter((f) => f.endsWith(".jsonl"))
+        .sort();
+    let last = "";
+    for (const file of files) {
+        const content = readFileSync(join(sessionDir, file), "utf-8");
+        for (const rawLine of content.split("\n")) {
+            const line = rawLine.trim();
+            if (!line)
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                if (entry.type !== "message")
+                    continue;
+                const msg = entry.message;
+                if (!msg || msg.role !== "assistant")
+                    continue;
+                const text = extractText(msg.content);
+                if (text)
+                    last = text;
+            }
+            catch {
+                /* skip malformed JSONL rows */
+            }
+        }
+    }
+    return last;
+}

package/dist/subagent/buildArgv.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Build `pi` CLI argv for subagent spawns.
+ */
+import type { AgentConfig } from "../helpers.js";
+export interface BuildPiArgvOptions {
+    agent: AgentConfig;
+    sessionName: string;
+    sessionDir: string;
+    promptContent: string;
+    resume?: boolean;
+    parentToolNames?: string[];
+}
+export declare function buildPiArgv(opts: BuildPiArgvOptions): string[];

package/dist/subagent/buildArgv.js

@@ -0,0 +1,25 @@
+/**
+ * Build `pi` CLI argv for subagent spawns.
+ */
+import { resolveAgentToolAllowlist } from "../agent-tools.js";
+export function buildPiArgv(opts) {
+    const { agent, sessionName, sessionDir, promptContent, resume } = opts;
+    const allowedTools = resolveAgentToolAllowlist({
+        tools: agent.tools,
+        disallowedTools: agent.disallowedTools,
+        parentToolNames: opts.parentToolNames,
+    });
+    const args = [];
+    if (agent.model)
+        args.push("--model", agent.model);
+    if (agent.thinking)
+        args.push("--thinking", agent.thinking);
+    args.push("--tools", allowedTools.join(","));
+    args.push("--name", sessionName);
+    args.push("--session-dir", sessionDir);
+    if (resume)
+        args.push("--session", sessionName);
+    args.push("--append-system-prompt", agent.body);
+    args.push(promptContent);
+    return args;
+}

package/dist/subagent/runSdk.d.ts

@@ -0,0 +1,17 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { AgentConfig } from "../helpers.js";
+export interface RunSdkSubagentOptions {
+    prompt: string;
+    agent: AgentConfig;
+    cwd: string;
+    ctx: ExtensionContext;
+    model?: string;
+    thinkingLevel?: string;
+    tools?: string[];
+    excludeTools?: string[];
+    systemPrompt?: string;
+}
+export declare function runSdkSubagent(options: RunSdkSubagentOptions): Promise<{
+    output: string;
+    sessionPath?: string;
+}>;

package/dist/subagent/runSdk.js

@@ -0,0 +1,63 @@
+function resolveModel(ctx, requested) {
+    const registry = ctx.modelRegistry;
+    const available = registry?.getAll?.() ?? registry?.getAvailable?.() ?? [];
+    if (requested) {
+        const [provider, ...rest] = requested.split("/");
+        const modelId = rest.join("/");
+        const byProvider = available.find((model) => {
+            return model?.provider?.id === provider && model?.id === modelId;
+        });
+        if (byProvider)
+            return byProvider;
+        const byId = available.find((model) => model?.id === requested || model?.name === requested);
+        if (byId)
+            return byId;
+    }
+    return available[0];
+}
+export async function runSdkSubagent(options) {
+    const model = resolveModel(options.ctx, options.model ?? options.agent.model);
+    if (!model) {
+        throw new Error("No model available for SDK subagent execution");
+    }
+    const { createAgentSession, DefaultResourceLoader } = await import("@earendil-works/pi-coding-agent");
+    const resourceLoader = new DefaultResourceLoader({
+        cwd: options.cwd,
+        systemPromptOverride: options.systemPrompt,
+    });
+    const { session } = await createAgentSession({
+        cwd: options.cwd,
+        model,
+        thinkingLevel: options.thinkingLevel,
+        tools: options.tools,
+        excludeTools: options.excludeTools,
+        resourceLoader,
+    });
+    await session.prompt(options.prompt);
+    const sessionPath = session.sessionFile;
+    const output = getLastAssistantText(session.messages);
+    return { output: output.trim(), sessionPath };
+}
+function getLastAssistantText(messages) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message?.role !== "assistant")
+            continue;
+        const content = message.content;
+        if (typeof content === "string")
+            return content;
+        if (Array.isArray(content)) {
+            return content
+                .map((part) => {
+                if (typeof part === "string")
+                    return part;
+                if (typeof part?.text === "string")
+                    return part.text;
+                return "";
+            })
+                .filter(Boolean)
+                .join("\n");
+        }
+    }
+    return "";
+}

package/dist/subagent/tmux.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Tmux helpers for subagent panes (shared by task extension).
+ */
+export declare function tmuxCmd(args: string[]): string;
+export declare function hasTmux(): boolean;
+export declare function paneExists(paneId: string): boolean;
+export declare function getCurrentPaneId(): string | null;
+export declare function splitWindowPane(cwd: string, command: string): {
+    paneId: string;
+    originalPane: string | null;
+};
+export declare function killAgentPane(paneId: string, originalPane: string | null): void;
+/** Inject keys into a running subagent pane (steer / follow-up). */
+export declare function tmuxSteerPane(paneId: string, message: string): void;

package/dist/subagent/tmux.js

@@ -0,0 +1,72 @@
+/**
+ * Tmux helpers for subagent panes (shared by task extension).
+ */
+import { execFileSync } from "node:child_process";
+export function tmuxCmd(args) {
+    return execFileSync("tmux", args, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+}
+export function hasTmux() {
+    try {
+        execFileSync("tmux", ["-V"], { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function paneExists(paneId) {
+    try {
+        const out = tmuxCmd(["list-panes", "-a", "-F", "#{pane_id}"]);
+        return out.split("\n").includes(paneId);
+    }
+    catch {
+        return false;
+    }
+}
+export function getCurrentPaneId() {
+    try {
+        return tmuxCmd(["display-message", "-p", "#{pane_id}"]);
+    }
+    catch {
+        return null;
+    }
+}
+export function splitWindowPane(cwd, command) {
+    const originalPane = getCurrentPaneId();
+    const paneId = tmuxCmd([
+        "split-window",
+        "-h",
+        "-P",
+        "-F",
+        "#{pane_id}",
+        "-c",
+        cwd,
+        command,
+    ]);
+    return { paneId, originalPane };
+}
+export function killAgentPane(paneId, originalPane) {
+    try {
+        tmuxCmd(["kill-pane", "-t", paneId]);
+    }
+    catch {
+        /* already dead */
+    }
+    if (originalPane) {
+        try {
+            tmuxCmd(["select-pane", "-t", originalPane]);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+/** Inject keys into a running subagent pane (steer / follow-up). */
+export function tmuxSteerPane(paneId, message) {
+    const escaped = message.replace(/'/g, `'\"'\"'`);
+    tmuxCmd(["send-keys", "-t", paneId, "-l", escaped]);
+    tmuxCmd(["send-keys", "-t", paneId, "Enter"]);
+}

package/dist/subagent/waitCompletion.d.ts

@@ -0,0 +1,17 @@
+export type TaskCompletionStatus = "running" | "completed" | "failed" | "cancelled" | "timeout";
+export interface TaskCompletionSnapshot {
+    status: TaskCompletionStatus;
+    content: string;
+    source?: "result-file" | "session-jsonl" | "pane" | "timeout" | "signal";
+}
+export interface TaskCompletionOptions {
+    resultPath: string;
+    sessionDir: string;
+    sessionName: string;
+    paneId?: string;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    pollMs?: number;
+}
+export declare function checkTaskCompletion(options: TaskCompletionOptions): Promise<TaskCompletionSnapshot>;
+export declare function waitForTaskCompletion(options: TaskCompletionOptions): Promise<TaskCompletionSnapshot>;

package/dist/subagent/waitCompletion.js

@@ -0,0 +1,66 @@
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { getLastAssistantTextFromSessionDir } from "../session-text.js";
+import { paneExists } from "./tmux.js";
+async function readResultFile(resultPath) {
+    if (!existsSync(resultPath))
+        return null;
+    const text = (await readFile(resultPath, "utf-8")).trim();
+    return text.length > 0 ? text : null;
+}
+function readSessionText(sessionDir, sessionName) {
+    const sessionPath = join(sessionDir, "sessions", sessionName);
+    const text = getLastAssistantTextFromSessionDir(sessionPath).trim();
+    return text.length > 0 ? text : null;
+}
+export async function checkTaskCompletion(options) {
+    const result = await readResultFile(options.resultPath);
+    if (result) {
+        return { status: "completed", content: result, source: "result-file" };
+    }
+    if (options.paneId && paneExists(options.paneId)) {
+        return { status: "running", content: "", source: "pane" };
+    }
+    const sessionText = readSessionText(options.sessionDir, options.sessionName);
+    if (sessionText) {
+        return {
+            status: "completed",
+            content: sessionText,
+            source: "session-jsonl",
+        };
+    }
+    if (options.paneId) {
+        return {
+            status: "failed",
+            content: "Task pane exited before producing a result or assistant response.",
+            source: "pane",
+        };
+    }
+    return { status: "running", content: "", source: "pane" };
+}
+export async function waitForTaskCompletion(options) {
+    const timeoutMs = options.timeoutMs ?? 30 * 60 * 1000;
+    const pollMs = options.pollMs ?? 1000;
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        if (options.signal?.aborted) {
+            return {
+                status: "cancelled",
+                content: "Task was cancelled.",
+                source: "signal",
+            };
+        }
+        const snapshot = await checkTaskCompletion(options);
+        if (snapshot.status !== "running")
+            return snapshot;
+        if (Date.now() >= deadline) {
+            return {
+                status: "timeout",
+                content: `Task timed out after ${Math.round(timeoutMs / 1000)}s without producing a result.`,
+                source: "timeout",
+            };
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollMs));
+    }
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@heyhuynhgiabuu/pi-task",
+  "version": "0.1.0",
+  "description": "Delegating task/subagent extension for Pi: foreground/background subagents, widgets, tmux observability, SDK fallback.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "agents",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "media"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "PI_XAI_SIDE_TOOLS=0 tsx --test test/helpers.test.ts",
+    "smoke": "PI_XAI_SIDE_TOOLS=0 tsx test/smoke.ts",
+    "prepack": "npm run build"
+  },
+  "keywords": [
+    "pi",
+    "pi-extension",
+    "agent",
+    "subagent",
+    "task",
+    "tmux"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@sinclair/typebox": "^0.34.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@types/node": "^20.0.0",
+    "tsx": "^4.20.6",
+    "typescript": "^5.0.0",
+    "@earendil-works/pi-tui": "*"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/heyhuynhgiabuu/pi-task.git"
+  },
+  "bugs": {
+    "url": "https://github.com/heyhuynhgiabuu/pi-task/issues"
+  },
+  "homepage": "https://github.com/heyhuynhgiabuu/pi-task#readme"
+}