@pasko70/pibo 1.0.0

package/dist/cli.js

@@ -0,0 +1,264 @@
+import { Command } from "commander";
+import { DEFAULT_PIBO_CONFIG_PATH, PIBO_CONFIG_KEYS, deletePiboConfigValue, getDisplayPiboConfigValue, loadPiboConfig, redactPiboConfig, savePiboConfig, setPiboConfigValue, } from "./config/config.js";
+import { parsePiboThinkingLevel } from "./core/thinking.js";
+async function createCliProfile(profileName) {
+    const { createDefaultPiboPluginRegistry, createGatewayProducerPiboProfile } = await import("./plugins/builtin.js");
+    if (profileName === "gateway-producer" || profileName === "pibo-gateway-producer") {
+        return createGatewayProducerPiboProfile();
+    }
+    return createDefaultPiboPluginRegistry().createProfile(profileName ?? "pibo-minimal");
+}
+function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+function printConfigKeys() {
+    for (const definition of PIBO_CONFIG_KEYS) {
+        const visibility = definition.secret === true ? "secret" : "public";
+        console.log(`${definition.key}\t${definition.type}\t${visibility}\t${definition.description}`);
+    }
+}
+function printRootDiscovery() {
+    console.log(printRootDiscoveryText());
+}
+function printConfigDiscovery() {
+    console.log(printConfigDiscoveryText());
+}
+function parsePort(value) {
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error("Port must be an integer between 1 and 65535");
+    }
+    return port;
+}
+export async function runPiboCli(argv = process.argv) {
+    if (argv[2] === "--help" || argv[2] === "-h") {
+        printRootDiscovery();
+        return;
+    }
+    if (argv[2] === "mcp") {
+        const { runMcpCli } = await import("./mcp/index.js");
+        await runMcpCli([argv[0] ?? "node", "pibo mcp", ...argv.slice(3)]);
+        return;
+    }
+    if (argv[2] === "tools") {
+        const { runToolsCli } = await import("./tools/index.js");
+        await runToolsCli([argv[0] ?? "node", "pibo tools", ...argv.slice(3)]);
+        return;
+    }
+    if (argv[2] === "pi-packages") {
+        const { runPiPackagesCli } = await import("./pi-packages/cli.js");
+        await runPiPackagesCli([argv[0] ?? "node", "pibo pi-packages", ...argv.slice(3)]);
+        return;
+    }
+    if (argv[2] === "debug") {
+        const { runDebugCli } = await import("./debug/index.js");
+        await runDebugCli([argv[0] ?? "node", "pibo debug", ...argv.slice(3)]);
+        return;
+    }
+    if (argv[2] === "config" && (argv[3] === "--help" || argv[3] === "-h" || argv.length === 3)) {
+        printConfigDiscovery();
+        return;
+    }
+    const program = new Command();
+    program.name("pibo").description("Agent-oriented CLI for Pibo").helpOption(false).showHelpAfterError();
+    program
+        .command("mcp")
+        .description("Interact with configured MCP servers")
+        .helpOption(false)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .argument("[args...]")
+        .action(async (args) => {
+        const { runMcpCli } = await import("./mcp/index.js");
+        await runMcpCli([argv[0] ?? "node", "pibo mcp", ...args]);
+    });
+    program
+        .command("tools")
+        .description("Install and inspect curated external CLI tools")
+        .helpOption(false)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .argument("[args...]")
+        .action(async (args) => {
+        const { runToolsCli } = await import("./tools/index.js");
+        await runToolsCli([argv[0] ?? "node", "pibo tools", ...args]);
+    });
+    program
+        .command("pi-packages")
+        .description("Register Pi Coding Agent packages")
+        .helpOption(false)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .argument("[args...]")
+        .action(async (args) => {
+        const { runPiPackagesCli } = await import("./pi-packages/cli.js");
+        await runPiPackagesCli([argv[0] ?? "node", "pibo pi-packages", ...args]);
+    });
+    program
+        .command("debug")
+        .description("Inspect local Pibo data")
+        .helpOption(false)
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .argument("[args...]")
+        .action(async (args) => {
+        const { runDebugCli } = await import("./debug/index.js");
+        await runDebugCli([argv[0] ?? "node", "pibo debug", ...args]);
+    });
+    const config = program.command("config").description(`Manage pibo config at ${DEFAULT_PIBO_CONFIG_PATH}`).helpOption(false);
+    config.action(() => {
+        printConfigDiscovery();
+    });
+    config
+        .command("set")
+        .argument("<key>")
+        .argument("<value>")
+        .description("Set a config value")
+        .action((key, value) => {
+        const nextConfig = setPiboConfigValue(loadPiboConfig(), key, value);
+        savePiboConfig(nextConfig);
+        console.log(`Set ${key}`);
+    });
+    config
+        .command("get")
+        .argument("<key>")
+        .description("Print a config value")
+        .action((key) => {
+        const value = getDisplayPiboConfigValue(loadPiboConfig(), key);
+        if (value === undefined) {
+            process.exitCode = 1;
+            return;
+        }
+        if (typeof value === "string")
+            console.log(value);
+        else
+            printJson(value);
+    });
+    config
+        .command("del")
+        .argument("<key>")
+        .description("Delete a config value")
+        .action((key) => {
+        savePiboConfig(deletePiboConfigValue(loadPiboConfig(), key));
+        console.log(`Deleted ${key}`);
+    });
+    config.command("keys").description("List supported config keys").action(printConfigKeys);
+    config
+        .command("show")
+        .description("Print the complete config")
+        .action(() => {
+        printJson(redactPiboConfig(loadPiboConfig()));
+    });
+    program
+        .command("profile")
+        .argument("[profile]")
+        .description("Inspect a pibo profile")
+        .action(async (profile) => {
+        const { inspectPiboProfile } = await import("./core/runtime.js");
+        printJson(await inspectPiboProfile({ profile: await createCliProfile(profile) }));
+    });
+    program
+        .command("tui")
+        .argument("[profile]")
+        .description("Start the Pi TUI through pibo")
+        .action(async (profile) => {
+        const { runPiboTui } = await import("./core/runtime.js");
+        await runPiboTui({ profile: await createCliProfile(profile) });
+    });
+    program
+        .command("tui:routed")
+        .option("--show-thinking", "Show routed thinking deltas in the local TUI")
+        .option("--thinking <level>", "Set routed thinking level: off, minimal, low, medium, high, xhigh", parsePiboThinkingLevel)
+        .argument("[profile]")
+        .description("Start the local routed Pibo TUI")
+        .action(async (profile, options) => {
+        const { runLocalRoutedTui } = await import("./local/tui.js");
+        await runLocalRoutedTui({
+            profile,
+            showThinking: options.showThinking === true,
+            thinkingLevel: options.thinking,
+        });
+    });
+    program
+        .command("router")
+        .argument("[piboSessionId]", "Pibo session id", "demo")
+        .description("Emit a demo router status event")
+        .action(async (piboSessionId) => {
+        const { PiboSessionRouter } = await import("./core/session-router.js");
+        const router = new PiboSessionRouter({ persistSession: false });
+        const event = await router.emit({
+            type: "execution",
+            piboSessionId,
+            action: "status",
+        });
+        printJson(event);
+        await router.disposeAll();
+    });
+    program
+        .command("gateway")
+        .description("Start the local pibo gateway daemon")
+        .action(async () => {
+        const { runGatewayServer } = await import("./gateway/server.js");
+        await runGatewayServer();
+    });
+    program
+        .command("gateway:web")
+        .description("Start the authenticated web gateway")
+        .option("--web-host <host>", "Bind the HTTP web host, for example 0.0.0.0 for LAN access")
+        .option("--web-port <port>", "Bind the HTTP web host port", parsePort)
+        .action(async (options) => {
+        const { runWebGatewayServer } = await import("./gateway/web.js");
+        await runWebGatewayServer({
+            web: {
+                host: options.webHost,
+                port: options.webPort,
+            },
+        });
+    });
+    program
+        .command("client")
+        .argument("[piboSessionId]", "Pibo session id", "default")
+        .description("Start a console gateway client")
+        .action(async (piboSessionId) => {
+        const { runGatewayClient } = await import("./gateway/client.js");
+        await runGatewayClient({ piboSessionId });
+    });
+    if (argv.length <= 2) {
+        printRootDiscovery();
+        return;
+    }
+    await program.parseAsync(argv);
+}
+function printRootDiscoveryText() {
+    return `pibo - agent-oriented CLI
+
+Commands:
+  config       Manage local pibo config
+  mcp          Discover and call configured MCP servers
+  tools        Install and inspect curated external CLI tools
+  pi-packages  Register Pi Coding Agent packages
+  debug        Inspect local Pibo data
+  profile      Inspect a pibo profile
+  tui          Start the direct Pi TUI
+  tui:routed   Start the local routed Pibo TUI
+  gateway      Start the local gateway daemon
+  gateway:web  Start the authenticated web gateway
+
+Next:
+  pibo <command> --help
+`;
+}
+function printConfigDiscoveryText() {
+    return `pibo config - local config at ${DEFAULT_PIBO_CONFIG_PATH}
+
+Commands:
+  keys               List supported config keys
+  show               Print redacted config JSON
+  get <key>          Print one redacted config value
+  set <key> <value>  Set one config value
+  del <key>          Delete one config value
+
+Next:
+  pibo config keys
+`;
+}

package/dist/config/config.js

@@ -0,0 +1,167 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+export const DEFAULT_PIBO_CONFIG_PATH = ".pibo/config.json";
+export const PIBO_CONFIG_KEYS = [
+    {
+        key: "auth.baseURL",
+        type: "string",
+        description: "Better Auth base URL, for example http://localhost:4788.",
+    },
+    {
+        key: "auth.secret",
+        type: "string",
+        secret: true,
+        description: "Better Auth secret. Must be at least 32 characters.",
+    },
+    {
+        key: "auth.googleClientId",
+        type: "string",
+        description: "Google OAuth client id.",
+    },
+    {
+        key: "auth.googleClientSecret",
+        type: "string",
+        secret: true,
+        description: "Google OAuth client secret.",
+    },
+    {
+        key: "auth.allowedEmails",
+        type: "string[]",
+        description: "Allowed Google account emails. Use comma-separated values.",
+    },
+    {
+        key: "auth.trustedOrigins",
+        type: "string[]",
+        description: "Additional trusted Better Auth origins. Use comma-separated values.",
+    },
+    {
+        key: "auth.databasePath",
+        type: "string",
+        description: "SQLite path for Better Auth data.",
+    },
+];
+function getKeyDefinition(key) {
+    const definition = PIBO_CONFIG_KEYS.find((candidate) => candidate.key === key);
+    if (!definition)
+        throw new Error(`Unknown config key "${key}"`);
+    return definition;
+}
+function findKeyDefinition(key) {
+    return PIBO_CONFIG_KEYS.find((candidate) => candidate.key === key);
+}
+function maskSecretValue(value) {
+    if (value.length <= 8)
+        return "********";
+    return `${value.slice(0, 4)}...${value.slice(-4)}`;
+}
+function parseListValue(value) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("[")) {
+        const parsed = JSON.parse(trimmed);
+        if (!Array.isArray(parsed) || parsed.some((item) => typeof item !== "string")) {
+            throw new Error("Expected a JSON string array");
+        }
+        return parsed.map((item) => item.trim()).filter(Boolean);
+    }
+    return trimmed
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function parseConfigValue(definition, value) {
+    if (definition.type === "string[]")
+        return parseListValue(value);
+    if (definition.key === "auth.secret" && value.length < 32) {
+        throw new Error("auth.secret must be at least 32 characters");
+    }
+    return value;
+}
+function assertObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Pibo config must be a JSON object");
+    }
+    return value;
+}
+export function loadPiboConfig(path = DEFAULT_PIBO_CONFIG_PATH) {
+    const resolvedPath = resolve(path);
+    if (!existsSync(resolvedPath))
+        return {};
+    const parsed = JSON.parse(readFileSync(resolvedPath, "utf-8"));
+    return assertObject(parsed);
+}
+export function savePiboConfig(config, path = DEFAULT_PIBO_CONFIG_PATH) {
+    const resolvedPath = resolve(path);
+    mkdirSync(dirname(resolvedPath), { recursive: true });
+    writeFileSync(resolvedPath, `${JSON.stringify(config, null, 2)}\n`);
+}
+export function getPiboConfigValue(config, key) {
+    getKeyDefinition(key);
+    const segments = key.split(".");
+    let current = config;
+    for (const segment of segments) {
+        if (!current || typeof current !== "object" || Array.isArray(current))
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+export function getDisplayPiboConfigValue(config, key) {
+    const definition = getKeyDefinition(key);
+    const value = getPiboConfigValue(config, key);
+    if (definition.secret && typeof value === "string")
+        return maskSecretValue(value);
+    return value;
+}
+export function redactPiboConfig(config) {
+    const redacted = structuredClone(config);
+    for (const definition of PIBO_CONFIG_KEYS) {
+        if (!definition.secret)
+            continue;
+        const value = getPiboConfigValue(config, definition.key);
+        if (typeof value !== "string")
+            continue;
+        const segments = definition.key.split(".");
+        let current = redacted;
+        for (const segment of segments.slice(0, -1)) {
+            const next = current[segment];
+            if (!next || typeof next !== "object" || Array.isArray(next)) {
+                current = {};
+                break;
+            }
+            current = next;
+        }
+        current[segments[segments.length - 1]] = maskSecretValue(value);
+    }
+    return redacted;
+}
+export function setPiboConfigValue(config, key, rawValue) {
+    const definition = getKeyDefinition(key);
+    const value = parseConfigValue(definition, rawValue);
+    const [section, name] = key.split(".");
+    if (section !== "auth" || !name)
+        throw new Error(`Unsupported config key "${key}"`);
+    return {
+        ...config,
+        auth: {
+            ...config.auth,
+            [name]: value,
+        },
+    };
+}
+export function isPiboConfigKeySecret(key) {
+    return findKeyDefinition(key)?.secret === true;
+}
+export function deletePiboConfigValue(config, key) {
+    getKeyDefinition(key);
+    const [section, name] = key.split(".");
+    if (section !== "auth" || !name)
+        throw new Error(`Unsupported config key "${key}"`);
+    if (!config.auth || !(name in config.auth))
+        return config;
+    const auth = { ...config.auth };
+    delete auth[name];
+    return {
+        ...config,
+        auth: Object.keys(auth).length > 0 ? auth : undefined,
+    };
+}

package/dist/core/base-prompt.js

@@ -0,0 +1,104 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const PROJECT_ROOT = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+export const PIBO_LIBRARY_BASE_PROMPT_PATH = resolve(PROJECT_ROOT, "context/pibo-system-prompt.md");
+function getBasePromptStatePath(cwd) {
+    return resolve(cwd, ".pibo/base-prompt.json");
+}
+function getCustomBasePromptPath(cwd) {
+    return resolve(cwd, ".pibo/base-prompt.md");
+}
+function normalizeMode(value) {
+    return value === "custom" ? "custom" : "library";
+}
+function readBasePromptState(cwd) {
+    const path = getBasePromptStatePath(cwd);
+    if (!existsSync(path))
+        return { mode: "library" };
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        return {
+            mode: normalizeMode(parsed.mode),
+            updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : undefined,
+        };
+    }
+    catch {
+        return { mode: "library" };
+    }
+}
+function writeBasePromptState(cwd, state) {
+    const path = getBasePromptStatePath(cwd);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(state, null, 2)}\n`);
+}
+export function getActivePiboBasePromptPath(cwd = process.cwd()) {
+    const legacyOverridePath = resolve(cwd, ".pibo/SYSTEM.md");
+    if (existsSync(legacyOverridePath))
+        return undefined;
+    const customPath = getCustomBasePromptPath(cwd);
+    const state = readBasePromptState(cwd);
+    if (state.mode === "custom" && existsSync(customPath))
+        return customPath;
+    return existsSync(PIBO_LIBRARY_BASE_PROMPT_PATH) ? PIBO_LIBRARY_BASE_PROMPT_PATH : undefined;
+}
+export async function readPiboBasePrompt(cwd = process.cwd()) {
+    const state = readBasePromptState(cwd);
+    const customPath = getCustomBasePromptPath(cwd);
+    const customExists = existsSync(customPath);
+    const [libraryMarkdown, customMarkdown] = await Promise.all([
+        readFile(PIBO_LIBRARY_BASE_PROMPT_PATH, "utf-8"),
+        customExists ? readFile(customPath, "utf-8") : Promise.resolve(""),
+    ]);
+    return {
+        mode: state.mode,
+        effectiveMode: state.mode === "custom" && customExists ? "custom" : "library",
+        library: {
+            path: PIBO_LIBRARY_BASE_PROMPT_PATH,
+            markdown: libraryMarkdown,
+        },
+        custom: {
+            path: customPath,
+            markdown: customMarkdown,
+            exists: customExists,
+            updatedAt: customExists ? state.updatedAt : undefined,
+        },
+    };
+}
+export async function savePiboCustomBasePrompt(markdown, cwd = process.cwd()) {
+    const path = getCustomBasePromptPath(cwd);
+    mkdirSync(dirname(path), { recursive: true });
+    const updatedAt = new Date().toISOString();
+    await writeFile(path, markdown);
+    writeBasePromptState(cwd, { mode: "custom", updatedAt });
+    return readPiboBasePrompt(cwd);
+}
+export function setPiboBasePromptMode(mode, cwd = process.cwd()) {
+    const existing = readBasePromptState(cwd);
+    const customPath = getCustomBasePromptPath(cwd);
+    if (mode === "custom" && !existsSync(customPath)) {
+        mkdirSync(dirname(customPath), { recursive: true });
+        writeFileSync(customPath, readFileSync(PIBO_LIBRARY_BASE_PROMPT_PATH, "utf-8"));
+    }
+    writeBasePromptState(cwd, {
+        mode,
+        updatedAt: mode === "custom" ? existing.updatedAt ?? new Date().toISOString() : existing.updatedAt,
+    });
+    const state = readBasePromptState(cwd);
+    const customExists = existsSync(customPath);
+    return {
+        mode: state.mode,
+        effectiveMode: state.mode === "custom" && customExists ? "custom" : "library",
+        library: {
+            path: PIBO_LIBRARY_BASE_PROMPT_PATH,
+            markdown: readFileSync(PIBO_LIBRARY_BASE_PROMPT_PATH, "utf-8"),
+        },
+        custom: {
+            path: customPath,
+            markdown: customExists ? readFileSync(customPath, "utf-8") : "",
+            exists: customExists,
+            updatedAt: customExists ? state.updatedAt : undefined,
+        },
+    };
+}

package/dist/core/codex-compat.js

@@ -0,0 +1,44 @@
+const CODEX_COMPAT_SUBAGENTS = ["default", "explorer", "worker"];
+function currentDate() {
+    return new Date().toISOString().slice(0, 10);
+}
+function currentTimezone() {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+}
+export function buildCodexCompatSystemPrompt(options) {
+    const childInstructions = options.isChildSession
+        ? [
+            "## Delegated Child Agent",
+            "You are a child agent working as part of a team. Complete the delegated task, continue the thread when the parent sends more input, and return a concise final result for the parent agent.",
+        ].join("\n")
+        : "";
+    const compatibilityInstructions = [
+        "# Codex-Compatible Runtime",
+        "You are running in Pibo through the codex-compat profile. Match Codex-style tool use where the exposed Pibo tools support it, while staying truthful about implemented behavior.",
+        "Use Pibo's pibo_run_* tools and generated pibo_subagent_* tools for parallel work, yielded runs, and child-agent lifecycle management.",
+        "Use direct execution for normal coding tasks. If a structured planning or user-input tool is not present, ask concise questions in normal chat.",
+        "When web_search is selected by the profile, use it for current or externally sourced information.",
+        childInstructions,
+        "<environment_context>",
+        `  <cwd>${options.cwd}</cwd>`,
+        `  <shell>${options.shell}</shell>`,
+        `  <current_date>${options.currentDate ?? currentDate()}</current_date>`,
+        `  <timezone>${options.timezone ?? currentTimezone()}</timezone>`,
+        `  <subagents>${CODEX_COMPAT_SUBAGENTS.join(", ")}</subagents>`,
+        "</environment_context>",
+        options.baseSystemPrompt,
+    ];
+    return compatibilityInstructions.filter((section) => section.trim().length > 0).join("\n\n");
+}
+export function createCodexCompatExtension(options = {}) {
+    return (pi) => {
+        pi.on("before_agent_start", (event, ctx) => ({
+            systemPrompt: buildCodexCompatSystemPrompt({
+                baseSystemPrompt: event.systemPrompt,
+                cwd: ctx.cwd,
+                shell: options.shell ?? process.env.SHELL ?? "bash",
+                isChildSession: options.isChildSession,
+            }),
+        }));
+    };
+}