@pasko70/pibo 1.4.5 → 1.5.0

package/dist/mcp/config.js

@@ -311,6 +311,17 @@ export function getDefaultConfigPaths() {
     paths.push(join(home, '.config', 'mcp', 'mcp_servers.json'));
     return paths;
 }
+export function getConfigSearchPaths(explicitPath) {
+    const paths = [];
+    if (explicitPath) {
+        paths.push(resolve(explicitPath));
+    }
+    if (process.env.MCP_CONFIG_PATH) {
+        paths.push(resolve(process.env.MCP_CONFIG_PATH));
+    }
+    paths.push(...getDefaultConfigPaths());
+    return [...new Set(paths)];
+}
 export function getPreferredConfigPath(explicitPath) {
     if (explicitPath) {
         return resolve(explicitPath);
@@ -341,38 +352,7 @@ export async function ensureConfigExists(explicitPath) {
     await writeFile(configPath, `${JSON.stringify({ mcpServers: {} }, null, 2)}\n`);
     return configPath;
 }
-/**
- * Load and parse MCP servers configuration
- */
-export async function loadConfig(explicitPath) {
-    let configPath;
-    // Check explicit path from argument or environment
-    if (explicitPath) {
-        configPath = resolve(explicitPath);
-    }
-    else if (process.env.MCP_CONFIG_PATH) {
-        configPath = resolve(process.env.MCP_CONFIG_PATH);
-    }
-    // If explicit path provided, it must exist
-    if (configPath) {
-        if (!existsSync(configPath)) {
-            throw new Error(formatCliError(configNotFoundError(configPath)));
-        }
-    }
-    else {
-        // Search default paths
-        const searchPaths = getDefaultConfigPaths();
-        for (const path of searchPaths) {
-            if (existsSync(path)) {
-                configPath = path;
-                break;
-            }
-        }
-        if (!configPath) {
-            throw new Error(formatCliError(configSearchError()));
-        }
-    }
-    // Read and parse config
+async function readRawConfig(configPath) {
     const content = await readFile(configPath, 'utf-8');
     let config;
     try {
@@ -381,45 +361,98 @@ export async function loadConfig(explicitPath) {
     catch (e) {
         throw new Error(formatCliError(configInvalidJsonError(configPath, e.message)));
     }
-    // Validate structure
     if (!config.mcpServers || typeof config.mcpServers !== 'object') {
         throw new Error(formatCliError(configMissingFieldError(configPath)));
     }
-    // Validate individual server configs
-    for (const [serverName, serverConfig] of Object.entries(config.mcpServers)) {
-        if (!serverConfig || typeof serverConfig !== 'object') {
-            throw new Error(formatCliError({
-                code: ErrorCode.CLIENT_ERROR,
-                type: 'CONFIG_INVALID_SERVER',
-                message: `Invalid server configuration for "${serverName}"`,
-                details: 'Server config must be an object',
-                suggestion: `Use { "command": "..." } for stdio or { "url": "..." } for HTTP`,
-            }));
-        }
-        const hasCommand = 'command' in serverConfig;
-        const hasUrl = 'url' in serverConfig;
-        if (!hasCommand && !hasUrl) {
-            throw new Error(formatCliError({
-                code: ErrorCode.CLIENT_ERROR,
-                type: 'CONFIG_INVALID_SERVER',
-                message: `Server "${serverName}" missing required field`,
-                details: `Must have either "command" (for stdio) or "url" (for HTTP)`,
-                suggestion: `Add "command": "npx ..." for local servers or "url": "https://..." for remote servers`,
-            }));
+    return config;
+}
+function validateServerConfig(serverName, serverConfig) {
+    if (!serverConfig || typeof serverConfig !== 'object') {
+        throw new Error(formatCliError({
+            code: ErrorCode.CLIENT_ERROR,
+            type: 'CONFIG_INVALID_SERVER',
+            message: `Invalid server configuration for "${serverName}"`,
+            details: 'Server config must be an object',
+            suggestion: `Use { "command": "..." } for stdio or { "url": "..." } for HTTP`,
+        }));
+    }
+    const hasCommand = 'command' in serverConfig;
+    const hasUrl = 'url' in serverConfig;
+    if (!hasCommand && !hasUrl) {
+        throw new Error(formatCliError({
+            code: ErrorCode.CLIENT_ERROR,
+            type: 'CONFIG_INVALID_SERVER',
+            message: `Server "${serverName}" missing required field`,
+            details: `Must have either "command" (for stdio) or "url" (for HTTP)`,
+            suggestion: `Add "command": "npx ..." for local servers or "url": "https://..." for remote servers`,
+        }));
+    }
+    if (hasCommand && hasUrl) {
+        throw new Error(formatCliError({
+            code: ErrorCode.CLIENT_ERROR,
+            type: 'CONFIG_INVALID_SERVER',
+            message: `Server "${serverName}" has both "command" and "url"`,
+            details: 'A server must be either stdio (command) or HTTP (url), not both',
+            suggestion: `Remove one of "command" or "url"`,
+        }));
+    }
+}
+/**
+ * Load and merge MCP servers configuration.
+ * More specific paths appear first and win server-name conflicts.
+ */
+export async function loadConfig(explicitPath) {
+    const explicitOrEnvPath = explicitPath
+        ? resolve(explicitPath)
+        : process.env.MCP_CONFIG_PATH
+            ? resolve(process.env.MCP_CONFIG_PATH)
+            : undefined;
+    if (explicitOrEnvPath && !existsSync(explicitOrEnvPath)) {
+        throw new Error(formatCliError(configNotFoundError(explicitOrEnvPath)));
+    }
+    const existingPaths = getConfigSearchPaths(explicitPath).filter((path) => existsSync(path));
+    if (existingPaths.length === 0) {
+        throw new Error(formatCliError(configSearchError()));
+    }
+    const merged = { mcpServers: {} };
+    for (const configPath of existingPaths) {
+        const config = await readRawConfig(configPath);
+        for (const [serverName, serverConfig] of Object.entries(config.mcpServers)) {
+            if (!(serverName in merged.mcpServers)) {
+                merged.mcpServers[serverName] = serverConfig;
+            }
         }
-        if (hasCommand && hasUrl) {
-            throw new Error(formatCliError({
-                code: ErrorCode.CLIENT_ERROR,
-                type: 'CONFIG_INVALID_SERVER',
-                message: `Server "${serverName}" has both "command" and "url"`,
-                details: 'A server must be either stdio (command) or HTTP (url), not both',
-                suggestion: `Remove one of "command" or "url"`,
-            }));
+    }
+    for (const [serverName, serverConfig] of Object.entries(merged.mcpServers)) {
+        validateServerConfig(serverName, serverConfig);
+    }
+    return substituteEnvVarsInObject(merged);
+}
+export async function getConfigSourceSummaries(explicitPath) {
+    const summaries = [];
+    for (const configPath of getConfigSearchPaths(explicitPath)) {
+        if (!existsSync(configPath)) {
+            summaries.push({ path: configPath, exists: false, servers: [] });
+            continue;
         }
+        const config = await readRawConfig(configPath);
+        summaries.push({
+            path: configPath,
+            exists: true,
+            servers: Object.keys(config.mcpServers),
+        });
     }
-    // Substitute environment variables
-    config = substituteEnvVarsInObject(config);
-    return config;
+    return summaries;
+}
+export function formatConfigSourceSummaries(summaries) {
+    return summaries
+        .map((summary) => {
+        const serverList = summary.exists
+            ? summary.servers.join(', ') || '(none)'
+            : '(not found)';
+        return `  - ${summary.path}: ${serverList}`;
+    })
+        .join('\n');
 }
 /**
  * Get a specific server config by name

package/dist/plugins/builtin.js

@@ -133,6 +133,11 @@ export const piboCorePlugin = definePiboPlugin({
             path: builtinSkillPath("pibo-docker-system"),
             kind: "builtin",
         });
+        api.registerSkill({
+            name: "graphify",
+            path: builtinSkillPath("graphify"),
+            kind: "builtin",
+        });
         api.registerSkill({
             name: "prd",
             path: builtinSkillPath("prd"),
@@ -245,7 +250,16 @@ export const piboCorePlugin = definePiboPlugin({
             slashCommands: ["thinking"],
             execute(context, event) {
                 const params = getThinkingParams(event);
-                return params.level ? context.setThinkingLevel(params.level) : context.getThinkingLevel();
+                if (!params.level)
+                    return { ...context.getThinkingLevel(), action: "show_thinking_menu" };
+                const previousLevel = context.getThinkingLevel().level;
+                const result = context.setThinkingLevel(params.level);
+                return {
+                    ...result,
+                    action: "set_thinking_level",
+                    previousLevel,
+                    changed: previousLevel !== result.level,
+                };
             },
         });
         api.registerGatewayAction({

package/dist/session-ui/terminalRows.js

@@ -8,7 +8,7 @@ export function buildCompactTerminalRows(traceView, options) {
     const flatNodes = flattenTraceNodes(traceView.nodes)
         .sort((left, right) => compareTraceNodes(left.node, right.node))
         .filter((item) => item.node.type !== "agent.turn" && (options.showThinking || item.node.type !== "model.reasoning"));
-    const candidates = flatNodes.map((item) => createRowCandidate(item.node, item.turnId));
+    const candidates = syncThinkingToolRows(flatNodes.map((item) => createRowCandidate(item.node, item.turnId)));
     return groupRelatedToolCandidates(candidates).map((candidate) => candidate.row);
 }
 function flattenTraceNodes(nodes, turnId) {
@@ -311,7 +311,7 @@ function createExecutionCommandRow(node) {
         return createStatusToolRow(node);
     }
     if (node.title === "thinking") {
-        return createThinkingToolRow(node);
+        return isThinkingLevelSetOutput(node.output) ? createThinkingLevelSetRow(node) : createThinkingToolRow(node);
     }
     if (node.title === "fast_mode") {
         return createFastModeToolRow(node);
@@ -369,6 +369,33 @@ function createThinkingToolRow(node) {
         expandable: false,
     };
 }
+function createThinkingLevelSetRow(node) {
+    const result = isRecord(node.output) ? node.output : undefined;
+    const level = stringValue(result?.level);
+    const changed = result?.changed !== false;
+    const supported = result?.supported !== false;
+    const label = !supported
+        ? "Thinking level is not supported by this model."
+        : level
+            ? changed ? `Thinking level set to ${level}.` : `Thinking level is already ${level}.`
+            : "Thinking level updated.";
+    return {
+        id: node.id,
+        kind: "execution.command",
+        status: mapStatus(node.status),
+        lines: [
+            {
+                prefix: "bullet",
+                tokens: [token(label, supported ? "green" : "dim", "semibold")],
+            },
+        ],
+        sourceNodeIds: [node.id],
+        input: node.input,
+        output: node.output,
+        error: node.error,
+        expandable: false,
+    };
+}
 function createFastModeToolRow(node) {
     const result = isRecord(node.output) ? node.output : undefined;
     const mode = result?.mode === "fast" ? "fast" : result?.mode === "normal" ? "normal" : undefined;
@@ -495,6 +522,33 @@ function sessionErrorDetailLines(details) {
         tokens: [token(`${label}: `, "dim"), token(value, "red")],
     }));
 }
+function syncThinkingToolRows(candidates) {
+    const latest = candidates.map((candidate) => candidate.row.output).filter(isThinkingOutput).at(-1);
+    if (!latest)
+        return [...candidates];
+    return candidates.map((candidate) => {
+        if (candidate.row.kind !== "tool.thinking" || !isRecord(candidate.row.output))
+            return candidate;
+        return {
+            ...candidate,
+            row: {
+                ...candidate.row,
+                output: {
+                    ...candidate.row.output,
+                    level: latest.level,
+                    availableLevels: latest.availableLevels,
+                    supported: latest.supported,
+                },
+            },
+        };
+    });
+}
+function isThinkingOutput(value) {
+    return isRecord(value) && typeof value.level === "string" && Array.isArray(value.availableLevels);
+}
+function isThinkingLevelSetOutput(value) {
+    return isRecord(value) && value.action === "set_thinking_level";
+}
 function groupRelatedToolCandidates(candidates) {
     const grouped = [];
     for (let index = 0; index < candidates.length; index += 1) {

package/dist/shared/trace-nodes.js

@@ -19,6 +19,9 @@ function areTraceNodesSorted(nodes) {
     return true;
 }
 export function compareTraceNodes(left, right) {
+    const bySameTurnPhase = compareSameTurnPhase(left, right);
+    if (bySameTurnPhase !== 0)
+        return bySameTurnPhase;
     const byStartTime = compareOptionalIsoTime(left.startedAt, right.startedAt);
     if (byStartTime !== 0)
         return byStartTime;
@@ -27,6 +30,15 @@ export function compareTraceNodes(left, right) {
         return byOrder;
     return left.id.localeCompare(right.id);
 }
+function compareSameTurnPhase(left, right) {
+    if (!left.eventId || left.eventId !== right.eventId)
+        return 0;
+    const leftPhase = left.orderKey?.phaseRank;
+    const rightPhase = right.orderKey?.phaseRank;
+    if (leftPhase === undefined || rightPhase === undefined)
+        return 0;
+    return leftPhase - rightPhase;
+}
 function compareOptionalIsoTime(left, right) {
     if (!left && !right)
         return 0;

package/dist/skills/cli.js

@@ -1,4 +1,5 @@
 import { Command } from "commander";
+import { createDefaultPiboPluginRegistry } from "../plugins/builtin.js";
 import { UserSkillManager } from "../user-skills/manager.js";
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
@@ -9,7 +10,30 @@ function printJson(value) {
 export async function runSkillsCli(argv) {
     const manager = new UserSkillManager(os.homedir());
     const program = new Command();
-    program.name("pibo skills").description("Manage Pibo user skills (not built-in or plugin skills)");
+    program
+        .name("pibo skills")
+        .description("Manage Pibo user skills and inspect the built-in/plugin skill catalog")
+        .addHelpText("after", "\nBuilt-in/plugin skills are selected by agent profiles. Run `pibo skills catalog` to list them.\n");
+    program
+        .command("catalog")
+        .description("List built-in and plugin skills available to profiles")
+        .option("--json", "Print JSON")
+        .action((options) => {
+        const registry = createDefaultPiboPluginRegistry();
+        const skills = registry.getCapabilityCatalog().skills.filter((skill) => skill.kind !== "user");
+        if (options.json) {
+            printJson(skills);
+            return;
+        }
+        if (skills.length === 0) {
+            console.log("No built-in or plugin skills registered.");
+            return;
+        }
+        console.log("NAME\tKIND\tPATH");
+        for (const skill of skills) {
+            console.log(`${skill.name}\t${skill.kind ?? "plugin"}\t${skill.path}`);
+        }
+    });
     program
         .command("list")
         .description("List user skills managed by this CLI")

package/dist/tools/guides.js

@@ -379,6 +379,77 @@ If \`browser-use --connect\` cannot find Chrome, ask the user whether they want
 14. If Chrome fails to start with a "SingletonLock" error, the wrapper auto-detects and terminates stale Chrome processes holding the lock. Retry your command.
 `,
 };
+export const GRAPHIFY_GUIDE = {
+    name: 'graphify',
+    description: 'Generate codebase knowledge graphs with the Graphify CLI.',
+    content: `---
+name: graphify
+description: Generates interactive codebase knowledge graphs and markdown reports from a workspace folder.
+allowed-tools: Bash(graphify:*)
+---
+
+# Codebase Visualization with Graphify
+
+Graphify turns a folder into derived artifacts under \`graphify-out/\`:
+
+- \`graphify-out/graph.html\` — an interactive clickable graph;
+- \`graphify-out/graph.json\` — machine-readable graph data;
+- \`graphify-out/GRAPH_REPORT.md\` — a markdown summary with key concepts and suggested questions.
+
+Use it when a user asks to graph, map, visualize, or quickly understand a repo/workspace shape.
+
+## Prerequisites
+
+Install and apply the Pibo tool environment:
+
+\`\`\`bash
+pibo tools install graphify
+eval "$(pibo tools env graphify)"
+graphify --help
+\`\`\`
+
+Inside the Pibo source repo, use \`npm run --silent dev -- tools ...\` while testing local changes:
+
+\`\`\`bash
+npm run --silent dev -- tools install graphify
+eval "$(npm run --silent dev -- tools env graphify)"
+\`\`\`
+
+The installer uses the PyPI package \`graphifyy\` and runs \`graphify install --platform pi\` so the CLI is ready for Pi/Pibo workflows.
+
+## Core Workflow
+
+1. Choose the workspace path. Prefer the active Pibo Room or session workspace boundary when known.
+2. Run Graphify from that folder or pass the target path explicitly. With \`graphifyy==0.9.x\`, \`graphify .\` writes extraction output under \`graphify-out/\`.
+3. For a code-only workspace without an LLM key, run \`graphify cluster-only . --no-label\` after extraction to produce the HTML graph and markdown report.
+4. Put generated artifacts in an ignored room/session artifact directory when possible; do not commit them unless the user explicitly asks.
+5. Read \`graphify-out/GRAPH_REPORT.md\` first, then open \`graphify-out/graph.html\` when an interactive view is useful.
+
+\`\`\`bash
+cd /path/to/workspace
+graphify .
+graphify cluster-only . --no-label
+ls graphify-out/graph.html graphify-out/graph.json graphify-out/GRAPH_REPORT.md
+\`\`\`
+
+## Pibo Usage Notes
+
+- For Room-bound work, graph the Room workspace rather than the agent harness checkout unless the user asks otherwise.
+- If generating inside a Git repo, check \`git status --short\` before and after so graph artifacts are not accidentally included in unrelated commits.
+- Code-only extraction can run without an LLM API key. Including docs, README files, papers, images, or semantic-labeling steps may require a configured Graphify backend/API key; if no key is available, graph a code-only subdirectory or skip semantic labels with \`cluster-only . --no-label\`.
+- For large monorepos, start with a subdirectory such as \`src/\`, a code package, or a docs folder only when the needed LLM backend is configured.
+- Treat graph output as derived data. Recompute on demand when the branch or workspace changes.
+
+## Next Commands
+
+\`\`\`bash
+pibo tools show graphify
+pibo tools guide graphify graphify
+pibo tools path graphify
+pibo tools doctor graphify
+\`\`\`
+`,
+};
 export const REMOTE_BROWSER_GUIDE = {
     name: 'remote-browser',
     description: 'Browser automation workflow for sandboxed or remote agents.',

package/dist/tools/index.js

@@ -166,9 +166,13 @@ function printEnv(name) {
         return;
     }
     const binDir = status.executablePath.replace(/\/[^/]+$/, '');
-    const wrapperPath = entry.name === 'agent-browser' ? ensureAgentBrowserWrapper(status) : ensureBrowserUseWrapper(status);
-    const wrapperBinDir = wrapperPath ? wrapperPath.replace(/\/[^/]+$/, '') : `${status.homeDir}/bin`;
-    console.log(`export PATH="${wrapperBinDir}:${binDir}:$PATH"`);
+    const wrapperPath = entry.name === 'browser-use'
+        ? ensureBrowserUseWrapper(status)
+        : entry.name === 'agent-browser'
+            ? ensureAgentBrowserWrapper(status)
+            : undefined;
+    const envBinDirs = wrapperPath ? `${wrapperPath.replace(/\/[^/]+$/, '')}:${binDir}` : binDir;
+    console.log(`export PATH="${envBinDirs}:$PATH"`);
     if (entry.runtime.homeEnvVar)
         console.log(`export ${entry.runtime.homeEnvVar}="${status.homeDir}"`);
     if (desktop.display)

package/dist/tools/python-runtime.js

@@ -123,8 +123,8 @@ export async function printToolPythonRuntimeDoctor(name, spec) {
     if (name === 'browser-use' && process.platform === 'linux' && !hasDesktopDisplay(detectDesktopEnv())) {
         printLinuxVirtualDisplayHint('  ');
     }
-    if (existsSync(paths.executablePath)) {
-        const doctor = await runBuffered(paths.executablePath, ['doctor'], getToolPythonRuntimeEnv(paths, spec));
+    if (existsSync(paths.executablePath) && spec.doctorArgs?.length) {
+        const doctor = await runBuffered(paths.executablePath, spec.doctorArgs, getToolPythonRuntimeEnv(paths, spec));
         console.log(`  tool doctor: ${doctor.ok ? 'ok' : 'failed'}`);
         if (doctor.output) {
             console.log(doctor.output.split('\n').map((line) => `    ${line}`).join('\n'));

package/dist/tools/registry.js

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { ensureAgentBrowserWrapper } from './agent-browser-wrapper.js';
 import { detectDesktopEnv, hasDesktopDisplay, printDesktopEnvStatus, printLinuxVirtualDisplayHint } from './desktop-env.js';
-import { AGENT_BROWSER_GUIDE, BROWSER_USE_GUIDE, RALPH_GUIDE, REMOTE_BROWSER_GUIDE } from './guides.js';
+import { AGENT_BROWSER_GUIDE, BROWSER_USE_GUIDE, GRAPHIFY_GUIDE, RALPH_GUIDE, REMOTE_BROWSER_GUIDE } from './guides.js';
 import { ensureLinuxVirtualDisplay } from './linux-virtual-display.js';
 import { getToolNpmRuntimePaths, installToolNpmRuntime, printToolNpmRuntimeDoctor, removeToolNpmRuntime, } from './npm-runtime.js';
 import { getToolPythonRuntimePaths, installToolPythonRuntime, runInheritedCommand, printToolPythonRuntimeDoctor, removeToolPythonRuntime, } from './python-runtime.js';
@@ -16,6 +16,7 @@ const REGISTRY = [
             executableName: 'browser-use',
             pythonVersion: '3.12',
             homeEnvVar: 'BROWSER_USE_HOME',
+            doctorArgs: ['doctor'],
         },
         guides: [BROWSER_USE_GUIDE, REMOTE_BROWSER_GUIDE],
         notes: [
@@ -59,6 +60,29 @@ const REGISTRY = [
             'Discover details with `npm run dev -- tools show agent-browser` and `npm run dev -- tools guide agent-browser agent-browser`.',
         ].join('\n'),
     },
+    {
+        name: 'graphify',
+        description: 'Codebase visualization CLI that generates interactive knowledge graphs and reports.',
+        runtime: {
+            packageName: 'graphifyy',
+            executableName: 'graphify',
+            pythonVersion: '3.12',
+            postInstallArgs: ['install', '--platform', 'pi'],
+        },
+        guides: [GRAPHIFY_GUIDE],
+        notes: [
+            'Installed on demand into an isolated Python virtual environment from the graphifyy package.',
+            'The installer runs graphify install --platform pi after package installation so Graphify is ready for Pi/Pibo workflows.',
+            'Graphify writes generated graph artifacts under graphify-out/; prefer an ignored room/session artifact directory unless the user explicitly wants repo files.',
+            'Guides are available through pibo tools guide and are not loaded into pibo profiles automatically.',
+        ],
+        agentContextSnippet: [
+            'Codebase visualization CLI for graphify-out/graph.html, graph.json, and GRAPH_REPORT.md.',
+            'Start with `eval "$(npm run --silent dev -- tools env graphify)"`.',
+            'No LLM key: run `graphify .` on code, then `graphify cluster-only . --no-label`.',
+            'Guide: `npm run dev -- tools guide graphify graphify`.',
+        ].join('\n'),
+    },
     {
         name: 'ralph',
         description: 'Pibo-native continuous agent job runner for implementation and debugging loops.',