npm - @pasko70/pibo - Versions diffs - 1.4.4 → 1.4.6 - Mend

@pasko70/pibo 1.4.4 → 1.4.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (38) hide show

package/dist/apps/chat-vscode-web/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
 		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
 		<meta name="theme-color" content="#101d22" />
 		<title>Pibo</title>
-		<script type="module" crossorigin src="/apps/chat-vscode/assets/index-C3GTPyDo.js"></script>
+		<script type="module" crossorigin src="/apps/chat-vscode/assets/index-CjOC7zYy.js"></script>
 		<link rel="stylesheet" crossorigin href="/apps/chat-vscode/assets/index-B5QK07zO.css">
 	</head>
 	<body>

package/dist/apps/cli-ui/inkMarkdown.js CHANGED Viewed

@@ -1,4 +1,5 @@
 import { sanitizeTerminalText, tokenizeJsonTextLine } from "./inkJson.js";
+import { highlightInkCodeLine, normalizeInkCodeLanguage } from "./inkSyntaxHighlighter.js";
 export function renderInkMarkdownLines(markdown, options = {}) {
     return renderInkMarkdownTerminalLines(markdown, options).map((line) => line.tokens.map((token) => token.text).join(""));
 }
@@ -105,14 +106,18 @@ function inlineMarkdownTokens(text, defaults = {}) {
     return tokens.filter((token) => token.text.length > 0);
 }
 function codeFenceTokens(sourceLine, language) {
-    if (isBashLanguage(language))
+    const normalizedLanguage = normalizeInkCodeLanguage(language);
+    if (isBashLanguage(normalizedLanguage))
         return [{ text: "  " }, ...tokenizeInkBashCommand(sourceLine)];
-    if (language === "json" || language === "jsonc")
+    if (normalizedLanguage === "json")
         return [{ text: "  " }, ...tokenizeJsonTextLine(sourceLine)];
+    const highlighted = highlightInkCodeLine(sourceLine, normalizedLanguage);
+    if (highlighted)
+        return [{ text: "  " }, ...highlighted];
     return [{ text: `  ${sourceLine}`, tone: "default" }];
 }
 function isBashLanguage(language) {
-    return ["bash", "sh", "shell", "zsh"].includes(language);
+    return language === "bash";
 }
 function line(tokens) {
     return { prefix: "none", tokens };

package/dist/apps/cli-ui/inkSyntaxHighlighter.js ADDED Viewed

@@ -0,0 +1,166 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const languageAliases = new Map([
+    ["sh", "bash"],
+    ["shell", "bash"],
+    ["shellscript", "bash"],
+    ["zsh", "bash"],
+    ["js", "javascript"],
+    ["mjs", "javascript"],
+    ["cjs", "javascript"],
+    ["ts", "typescript"],
+    ["mts", "typescript"],
+    ["cts", "typescript"],
+    ["md", "markdown"],
+    ["yml", "yaml"],
+    ["jsonc", "json"],
+    ["py", "python"],
+    ["rs", "rust"],
+]);
+const grammarComponents = {
+    bash: ["bash"],
+    css: ["css"],
+    go: ["go"],
+    html: ["markup"],
+    javascript: ["javascript"],
+    json: ["json"],
+    jsx: ["markup", "javascript", "jsx"],
+    markdown: ["markup", "markdown"],
+    python: ["python"],
+    rust: ["rust"],
+    sql: ["sql"],
+    tsx: ["markup", "javascript", "jsx", "typescript", "tsx"],
+    typescript: ["javascript", "typescript"],
+    yaml: ["yaml"],
+};
+const loadedComponents = new Set();
+let prismInstance;
+export function highlightInkCodeLine(sourceLine, language) {
+    if (shouldUsePlainCodeTokens())
+        return [{ text: sourceLine, tone: "default" }];
+    const normalizedLanguage = normalizeInkCodeLanguage(language);
+    const prism = loadPrism();
+    if (!loadGrammar(prism, normalizedLanguage))
+        return undefined;
+    const grammar = prism.languages[normalizedLanguage];
+    if (!grammar)
+        return undefined;
+    try {
+        return flattenPrismTokens(prism.tokenize(sourceLine, grammar));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function normalizeInkCodeLanguage(language) {
+    const normalized = language.trim().toLowerCase();
+    return languageAliases.get(normalized) ?? normalized;
+}
+function loadPrism() {
+    prismInstance ??= require("prismjs");
+    return prismInstance;
+}
+function loadGrammar(prism, language) {
+    const components = grammarComponents[language];
+    if (!components)
+        return false;
+    for (const component of components) {
+        if (loadedComponents.has(component))
+            continue;
+        require(`prismjs/components/prism-${component}.js`);
+        loadedComponents.add(component);
+    }
+    return Boolean(prism.languages[language]);
+}
+function flattenPrismTokens(tokens, inheritedTone = "default") {
+    const result = [];
+    for (const token of tokens) {
+        if (typeof token === "string") {
+            if (token.length > 0)
+                result.push({ text: token, tone: inheritedTone });
+            continue;
+        }
+        const tone = toneForPrismToken(token) ?? inheritedTone;
+        appendPrismContent(result, token.content, tone);
+    }
+    return mergeAdjacentTokens(result);
+}
+function appendPrismContent(result, content, tone) {
+    if (typeof content === "string") {
+        if (content.length > 0)
+            result.push({ text: content, tone });
+        return;
+    }
+    if (Array.isArray(content)) {
+        result.push(...flattenPrismTokens(content, tone));
+        return;
+    }
+    const nestedTone = toneForPrismToken(content) ?? tone;
+    appendPrismContent(result, content.content, nestedTone);
+}
+function toneForPrismToken(token) {
+    const classes = [token.type, ...aliasesForToken(token)];
+    for (const className of classes) {
+        switch (className) {
+            case "comment":
+            case "prolog":
+            case "doctype":
+            case "cdata":
+                return "dim";
+            case "string":
+            case "char":
+            case "attr-value":
+            case "url":
+                return "green";
+            case "number":
+            case "boolean":
+            case "constant":
+                return "blue";
+            case "keyword":
+            case "operator":
+            case "punctuation":
+            case "important":
+            case "atrule":
+                return "magenta";
+            case "function":
+            case "method":
+            case "selector":
+            case "class-name":
+                return "yellow";
+            case "tag":
+            case "property":
+            case "attr-name":
+            case "variable":
+            case "regex":
+                return "cyan";
+            case "builtin":
+            case "symbol":
+            case "deleted":
+                return "red";
+            default:
+                break;
+        }
+    }
+    return undefined;
+}
+function aliasesForToken(token) {
+    if (!token.alias)
+        return [];
+    return Array.isArray(token.alias) ? token.alias : [token.alias];
+}
+function mergeAdjacentTokens(tokens) {
+    const merged = [];
+    for (const token of tokens) {
+        const previous = merged[merged.length - 1];
+        if (previous && previous.tone === token.tone && previous.weight === token.weight && previous.italic === token.italic) {
+            previous.text += token.text;
+        }
+        else {
+            merged.push({ ...token });
+        }
+    }
+    return merged;
+}
+function shouldUsePlainCodeTokens() {
+    return Boolean(process.env.NO_COLOR) || process.env.TERM === "dumb" || process.env.PIBO_ASCII_PROGRESS === "1";
+}

package/dist/apps/vscode-artifacts/latest.vsix CHANGED Viewed

Binary file

package/dist/apps/vscode-artifacts/{pibo-vscode-ext-1.4.4.vsix → pibo-vscode-ext-1.4.6.vsix} RENAMED Viewed

Binary file

package/dist/cli.js CHANGED Viewed

@@ -1,3 +1,4 @@
+import { readFileSync } from "node:fs";
 import { Command } from "commander";
 import { PIBO_CONFIG_KEYS, getDefaultPiboConfigPath, deletePiboConfigValue, getDisplayPiboConfigValue, loadPiboConfig, redactPiboConfig, savePiboConfig, setPiboConfigValue, } from "./config/config.js";
 import { parsePiboThinkingLevel } from "./core/thinking.js";
@@ -20,6 +21,16 @@ function printConfigKeys() {
 function printRootDiscovery() {
     console.log(printRootDiscoveryText());
 }
+function getPiboVersion() {
+    const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+    if (typeof packageJson.version !== "string" || packageJson.version.length === 0) {
+        throw new Error("Unable to read Pibo package version");
+    }
+    return packageJson.version;
+}
+function printPiboVersion() {
+    console.log(getPiboVersion());
+}
 function printConfigDiscovery() {
     console.log(printConfigDiscoveryText());
 }
@@ -46,6 +57,10 @@ export async function runPiboCli(argv = process.argv) {
         printRootDiscovery();
         return;
     }
+    if (argv[2] === "--version" || argv[2] === "-V") {
+        printPiboVersion();
+        return;
+    }
     if (argv[2] === "mcp") {
         const { runMcpCli } = await import("./mcp/index.js");
         await runMcpCli([argv[0] ?? "node", "pibo mcp", ...argv.slice(3)]);
@@ -348,6 +363,7 @@ export async function runPiboCli(argv = process.argv) {
         .option("--auth <mode>", "Auth service mode: 'better-auth' (default) or 'local' (loopback-only, no Google OAuth)")
         .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)
+        .option("--gateway-port <port>", "Bind the agent-runtime gateway port", parsePort)
         .action(async (options) => {
         const { runWebGatewayServer } = await import("./gateway/web.js");
         const authMode = options.auth;
@@ -360,6 +376,7 @@ export async function runPiboCli(argv = process.argv) {
         }
         await runWebGatewayServer({
             authMode: authMode,
+            port: options.gatewayPort,
             web: {
                 host: options.webHost,
                 port: options.webPort,
@@ -403,6 +420,9 @@ Commands:
   gateway      Inspect and restart host gateways through safe CLI commands
   gateway:web  Start a web gateway runtime (use --auth=local for loopback-only local auth)
+Options:
+  --version    Print the Pibo CLI version
 Next:
   pibo <command> --help
 `;

package/dist/mcp/agent-context.js CHANGED Viewed

@@ -1,5 +1,5 @@
 import { readFile, writeFile } from 'node:fs/promises';
-import { ensureConfigExists, findConfigPath, isHttpServer, } from './config.js';
+import { ensureConfigExists, isHttpServer, loadConfig, } from './config.js';
 import { ErrorCode, formatCliError } from './errors.js';
 export const MCP_SERVER_DESCRIPTION_MAX_LENGTH = 480;
 export const ENABLED_MCP_SERVERS_CONTEXT_PATH = '.pibo/context/enabled-mcp-servers.md';
@@ -22,11 +22,15 @@ export function normalizeMcpServerDescription(value) {
     return description;
 }
 export async function listMcpServerInfos(configPath) {
-    const path = findConfigPath(configPath);
-    if (!path)
-        return [];
-    const config = await readMcpConfig(path);
-    return Object.entries(config.mcpServers).map(([name, server]) => mcpServerInfoFromConfig(name, server));
+    try {
+        const config = await loadConfig(configPath);
+        return Object.entries(config.mcpServers).map(([name, server]) => mcpServerInfoFromConfig(name, server));
+    }
+    catch (error) {
+        if (error.message.includes('CONFIG_NOT_FOUND'))
+            return [];
+        throw error;
+    }
 }
 export async function setMcpServerDescription(serverName, descriptionInput, configPath) {
     const description = normalizeMcpServerDescription(descriptionInput);

package/dist/mcp/commands/info.js CHANGED Viewed

@@ -2,7 +2,7 @@
  * Info command - Show server or tool details
  */
 import { getConnection, safeClose } from '../client.js';
-import { getServerConfig, loadConfig, } from '../config.js';
+import { formatConfigSourceSummaries, getConfigSourceSummaries, loadConfig, } from '../config.js';
 import { ErrorCode, formatCliError, serverConnectionError, toolNotFoundError, } from '../errors.js';
 import { formatServerDetails, formatToolSchema } from '../output.js';
 /**
@@ -28,12 +28,24 @@ export async function infoCommand(options) {
         process.exit(ErrorCode.CLIENT_ERROR);
     }
     const { server: serverName, tool: toolName } = parseTarget(options.target);
-    let serverConfig;
-    try {
-        serverConfig = getServerConfig(config, serverName);
-    }
-    catch (error) {
-        console.error(error.message);
+    const serverConfig = config.mcpServers[serverName];
+    if (!serverConfig) {
+        const available = Object.keys(config.mcpServers);
+        const serverList = available.length > 0 ? available.join(', ') : '(none)';
+        const summaries = await getConfigSourceSummaries(options.configPath);
+        console.error(formatCliError({
+            code: ErrorCode.CLIENT_ERROR,
+            type: 'SERVER_NOT_FOUND',
+            message: `Server "${serverName}" not found in config`,
+            details: [
+                `Merged available servers: ${serverList}`,
+                'Config search paths:',
+                formatConfigSourceSummaries(summaries),
+            ].join('\n'),
+            suggestion: available.length > 0
+                ? `Use one of: ${available.map((s) => `pibo mcp info ${s}`).join(', ')}`
+                : `Add server to mcp_servers.json: { "mcpServers": { "${serverName}": { ... } } }`,
+        }));
         process.exit(ErrorCode.CLIENT_ERROR);
     }
     let connection;

package/dist/mcp/config.js CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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/plugins/codex-compat.js CHANGED Viewed

@@ -1,5 +1,6 @@
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createCodexImageGenerationToolProfile } from "../tools/codex-image-generation.js";
 import { definePiboPlugin } from "./registry.js";
 const CODEX_COMPAT_REGISTERED_TOOL_NAMES = [
     "apply_patch",
@@ -22,6 +23,7 @@ export const piboCodexCompatPlugin = definePiboPlugin({
                 description: toolDescriptions[name],
             });
         }
+        api.registerTool(createCodexImageGenerationToolProfile());
         api.registerContextFile({
             key: CODEX_BASE_PROMPT_CONTEXT_FILE_KEY,
             label: "Codex Base Prompt",