@bike4mind/cli 0.2.56 → 0.2.57-feat-jupyter-interoperability-roadmap.21458

package/dist/{artifactExtractor-ABHS5PT3.js → artifactExtractor-GTMSICU4.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   CurationArtifactType
-} from "./chunk-I5ZF2OVL.js";
+} from "./chunk-VWH4PFPB.js";
 
 // ../../b4m-core/packages/services/dist/src/notebookCurationService/artifactExtractor.js
 var ARTIFACT_TAG_REGEX = /<artifact\s+(.*?)>([\s\S]*?)<\/artifact>/gi;

package/dist/{chunk-524RAWPN.js → chunk-3JJYLK4C.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   ChatModels
-} from "./chunk-I5ZF2OVL.js";
+} from "./chunk-VWH4PFPB.js";
 import {
   DEFAULT_SANDBOX_CONFIG
 } from "./chunk-4BIBE3J7.js";

package/dist/{chunk-S27A7SCI.js → chunk-67YAACDQ.js}

@@ -7,11 +7,11 @@ import {
   getSettingsMap,
   getSettingsValue,
   secureParameters
-} from "./chunk-KGAK226I.js";
+} from "./chunk-AWG7GGY5.js";
 import {
   KnowledgeType,
   SupportedFabFileMimeTypes
-} from "./chunk-I5ZF2OVL.js";
+} from "./chunk-VWH4PFPB.js";
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/create.js
 import { z } from "zod";

package/dist/{chunk-KGAK226I.js → chunk-AWG7GGY5.js}

@@ -20,7 +20,7 @@ import {
   extractSnippetMeta,
   isGPTImageModel,
   settingsMap
-} from "./chunk-I5ZF2OVL.js";
+} from "./chunk-VWH4PFPB.js";
 
 // ../../b4m-core/packages/utils/dist/src/storage/S3Storage.js
 import { S3Client, PutObjectCommand, DeleteObjectCommand, GetObjectCommand, HeadObjectCommand } from "@aws-sdk/client-s3";

package/dist/{chunk-SA2GRZGG.js → chunk-O55VX62E.js}

@@ -4,7 +4,7 @@ import {
   getOpenWeatherKey,
   getSerperKey,
   getWolframAlphaKey
-} from "./chunk-XACIOJZ7.js";
+} from "./chunk-YKQNMQX5.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -16,14 +16,14 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-KGAK226I.js";
+} from "./chunk-AWG7GGY5.js";
 import {
   Logger
 } from "./chunk-PFBYGCOW.js";
 import {
   ConfigStore,
   logger
-} from "./chunk-524RAWPN.js";
+} from "./chunk-3JJYLK4C.js";
 import {
   ALERT_THRESHOLDS,
   AiEvents,
@@ -84,7 +84,7 @@ import {
   getViewById,
   resolveNavigationIntents,
   sanitizeTelemetryError
-} from "./chunk-I5ZF2OVL.js";
+} from "./chunk-VWH4PFPB.js";
 
 // src/utils/fileSearch.ts
 import * as fs from "fs";
@@ -11981,6 +11981,244 @@ BLOCKED OPERATIONS:
   })
 };
 
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/jupyterNotebook/notebookStructure.js
+var KERNEL_CONFIGS = {
+  python3: {
+    display_name: "Python 3",
+    language: "python",
+    language_info: {
+      name: "python",
+      version: "3.10",
+      mimetype: "text/x-python",
+      file_extension: ".py",
+      codemirror_mode: { name: "ipython", version: 3 },
+      pygments_lexer: "ipython3",
+      nbconvert_exporter: "python"
+    }
+  },
+  python: {
+    display_name: "Python",
+    language: "python",
+    language_info: {
+      name: "python",
+      version: "3.10",
+      mimetype: "text/x-python",
+      file_extension: ".py",
+      codemirror_mode: { name: "ipython", version: 3 },
+      pygments_lexer: "ipython3",
+      nbconvert_exporter: "python"
+    }
+  },
+  ir: {
+    display_name: "R",
+    language: "R",
+    language_info: {
+      name: "R",
+      version: "4.3",
+      mimetype: "text/x-r-source",
+      file_extension: ".r",
+      codemirror_mode: "r"
+    }
+  },
+  "julia-1.9": {
+    display_name: "Julia 1.9",
+    language: "julia",
+    language_info: {
+      name: "julia",
+      version: "1.9",
+      mimetype: "application/julia",
+      file_extension: ".jl"
+    }
+  },
+  "julia-1.10": {
+    display_name: "Julia 1.10",
+    language: "julia",
+    language_info: {
+      name: "julia",
+      version: "1.10",
+      mimetype: "application/julia",
+      file_extension: ".jl"
+    }
+  }
+};
+function createEmptyNotebook(kernelName = "python3") {
+  const config = KERNEL_CONFIGS[kernelName] ?? KERNEL_CONFIGS["python3"];
+  return {
+    nbformat: 4,
+    nbformat_minor: 5,
+    metadata: {
+      kernelspec: {
+        name: kernelName,
+        display_name: config.display_name,
+        language: config.language
+      },
+      language_info: config.language_info
+    },
+    cells: []
+  };
+}
+function generateCellId() {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let id = "";
+  for (let i = 0; i < 8; i++) {
+    id += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return id;
+}
+function normalizeSource(source) {
+  const lines = source.split("\n");
+  return lines.map((line, index) => index < lines.length - 1 ? line + "\n" : line);
+}
+function addCodeCell(notebook, code, metadata = {}) {
+  notebook.cells.push({
+    cell_type: "code",
+    id: generateCellId(),
+    source: normalizeSource(code),
+    metadata,
+    outputs: [],
+    execution_count: null
+  });
+}
+function addMarkdownCell(notebook, markdown, metadata = {}) {
+  notebook.cells.push({
+    cell_type: "markdown",
+    id: generateCellId(),
+    source: normalizeSource(markdown),
+    metadata
+  });
+}
+function serializeNotebook(notebook) {
+  return JSON.stringify(notebook, null, 1);
+}
+
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/jupyterNotebook/index.js
+var NOTEBOOK_GENERATION_PROMPT = `You are an expert data scientist generating a Jupyter notebook.
+
+Create a well-structured notebook that:
+1. Starts with a markdown cell explaining the analysis objective
+2. Includes necessary imports in the first code cell
+3. Loads and explores the data
+4. Performs the requested analysis
+5. Visualizes results where appropriate
+6. Ends with a summary markdown cell
+
+Guidelines:
+- Use pandas for data manipulation
+- Use matplotlib/seaborn for basic visualizations
+- Use plotly for interactive charts if requested
+- Include comments explaining key steps
+- Handle potential errors gracefully
+- Print intermediate results for debugging
+
+Return the notebook content as a JSON object with this structure:
+{
+  "title": "Notebook title",
+  "cells": [
+    { "type": "markdown", "content": "# Title\\n\\nDescription..." },
+    { "type": "code", "content": "import pandas as pd\\nimport numpy as np" },
+    ...
+  ]
+}`;
+function parseNotebookResponse(response) {
+  const jsonMatch = response.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error("Failed to parse notebook structure from LLM response");
+  }
+  try {
+    const parsed = JSON.parse(jsonMatch[0]);
+    if (!parsed.cells || !Array.isArray(parsed.cells)) {
+      throw new Error("Invalid notebook structure: missing cells array");
+    }
+    return parsed;
+  } catch (e) {
+    throw new Error(`Failed to parse notebook JSON: ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+function buildNotebook(response, kernelName, metadata) {
+  const notebook = createEmptyNotebook(kernelName);
+  notebook.metadata.title = response.title;
+  notebook.metadata.b4m_metadata = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...metadata
+  };
+  for (const cell of response.cells) {
+    if (cell.type === "markdown") {
+      addMarkdownCell(notebook, cell.content);
+    } else if (cell.type === "code") {
+      addCodeCell(notebook, cell.content);
+    }
+  }
+  return notebook;
+}
+var jupyterNotebookTool = {
+  name: "generate_jupyter_notebook",
+  implementation: (context) => ({
+    toolFn: async (value) => {
+      const params = value;
+      const { analysisDescription, dataSource, outputFormat, kernelName, title } = params;
+      if (!analysisDescription) {
+        throw new Error("analysisDescription is required");
+      }
+      const userPrompt = `Generate a Jupyter notebook for the following analysis:
+
+**Analysis Description:** ${analysisDescription}
+${dataSource ? `**Data Source:** ${dataSource}` : ""}
+${outputFormat ? `**Output Format:** ${outputFormat}` : ""}
+${title ? `**Notebook Title:** ${title}` : ""}
+
+Please generate a complete, well-structured notebook that performs this analysis.`;
+      context.logger.info("[JupyterNotebook] Generating notebook structure via LLM...");
+      let responseText = "";
+      await context.llm.complete(context.model ?? "gpt-4", [
+        { role: "system", content: NOTEBOOK_GENERATION_PROMPT },
+        { role: "user", content: userPrompt }
+      ], { maxTokens: 4e3, temperature: 0.7 }, async (texts) => {
+        responseText = texts.filter((t) => t !== null && t !== void 0).join("");
+      });
+      if (!responseText) {
+        throw new Error("LLM returned empty response");
+      }
+      const parsedResponse = parseNotebookResponse(responseText);
+      const notebook = buildNotebook(parsedResponse, kernelName || "python3", {
+        analysisDescription
+      });
+      context.logger.info(`[JupyterNotebook] Generated notebook with ${notebook.cells.length} cells`);
+      return serializeNotebook(notebook);
+    },
+    toolSchema: {
+      name: "generate_jupyter_notebook",
+      description: `Generate a Jupyter notebook for data analysis. The notebook will be created with Python code cells that can be executed locally via the Keep command system. Use this tool when the user wants to perform data analysis, create visualizations, or work with datasets.`,
+      parameters: {
+        type: "object",
+        properties: {
+          analysisDescription: {
+            type: "string",
+            description: "Detailed description of the analysis to perform. Be specific about what calculations, visualizations, or insights are needed."
+          },
+          dataSource: {
+            type: "string",
+            description: 'Description of the data source. Can be a file path (e.g., "~/data/sales.csv"), URL, or description of inline data.'
+          },
+          outputFormat: {
+            type: "string",
+            enum: ["table", "chart", "both"],
+            description: 'Preferred output format for results. "table" for tabular data, "chart" for visualizations, "both" for both.'
+          },
+          kernelName: {
+            type: "string",
+            description: 'Jupyter kernel to use. Defaults to "python3". Other options depend on what kernels are installed locally.'
+          },
+          title: {
+            type: "string",
+            description: "Optional title for the notebook."
+          }
+        },
+        required: ["analysisDescription"]
+      }
+    }
+  })
+};
+
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/excelGeneration/index.js
 import ExcelJS from "exceljs";
 import { v4 as uuidv47 } from "uuid";
@@ -13841,6 +14079,8 @@ var b4mTools = {
   quantum_formulate: quantumFormulateTool,
   // Navigation tool
   navigate_view: navigateViewTool,
+  // Jupyter notebook generation
+  generate_jupyter_notebook: jupyterNotebookTool,
   // Excel generation
   excel_generation: excelGenerationTool
 };

package/dist/{chunk-VILQBYE6.js → chunk-RIFFSKKB.js}

@@ -2,7 +2,7 @@
 import {
   BadRequestError,
   secureParameters
-} from "./chunk-KGAK226I.js";
+} from "./chunk-AWG7GGY5.js";
 import {
   CompletionApiUsageTransaction,
   GenericCreditDeductTransaction,
@@ -13,7 +13,7 @@ import {
   ToolUsageTransaction,
   TransferCreditTransaction,
   VideoGenerationUsageTransaction
-} from "./chunk-I5ZF2OVL.js";
+} from "./chunk-VWH4PFPB.js";
 
 // ../../b4m-core/packages/services/dist/src/creditService/subtractCredits.js
 import { z } from "zod";

package/dist/{chunk-5UDVBQZ7.js → chunk-TYXGSRCJ.js}

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.56",
+  version: "0.2.57-feat-jupyter-interoperability-roadmap.21458+b5aabe927",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -118,11 +118,11 @@ var package_default = {
     zustand: "^4.5.4"
   },
   devDependencies: {
-    "@bike4mind/agents": "0.2.1",
-    "@bike4mind/common": "2.70.1",
-    "@bike4mind/mcp": "1.33.15",
-    "@bike4mind/services": "2.64.3",
-    "@bike4mind/utils": "2.15.9",
+    "@bike4mind/agents": "0.2.2-feat-jupyter-interoperability-roadmap.21458+b5aabe927",
+    "@bike4mind/common": "2.70.2-feat-jupyter-interoperability-roadmap.21458+b5aabe927",
+    "@bike4mind/mcp": "1.33.16-feat-jupyter-interoperability-roadmap.21458+b5aabe927",
+    "@bike4mind/services": "2.64.4-feat-jupyter-interoperability-roadmap.21458+b5aabe927",
+    "@bike4mind/utils": "2.15.10-feat-jupyter-interoperability-roadmap.21458+b5aabe927",
     "@types/better-sqlite3": "^7.6.13",
     "@types/jsonwebtoken": "^9.0.4",
     "@types/node": "^22.9.0",
@@ -139,7 +139,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.1"
   },
-  gitHead: "bf6c3f4e7997e0ab0796c64ccd6b46d6d1fce954"
+  gitHead: "b5aabe927ab8e991be795c9a1e998f921eaf3452"
 };
 
 // src/utils/updateChecker.ts

package/dist/{chunk-I5ZF2OVL.js → chunk-VWH4PFPB.js}

@@ -338,6 +338,8 @@ var b4mLLMTools = z5.enum([
   "quantum_formulate",
   // Navigation tool
   "navigate_view",
+  // Jupyter notebook generation
+  "generate_jupyter_notebook",
   // Excel generation
   "excel_generation"
 ]);
@@ -1820,16 +1822,26 @@ var CliToolResponseAction = z11.object({
   content: z11.unknown().optional(),
   error: z11.string().optional()
 });
+var KeepCommandType = z11.enum([
+  "read_file",
+  "list_directory",
+  "run_tool",
+  // Jupyter kernel commands
+  "jupyter_start_kernel",
+  "jupyter_execute_cell",
+  "jupyter_stop_kernel",
+  "jupyter_get_kernelspecs"
+]);
 var KeepCommandRequestAction = z11.object({
   action: z11.literal("keep_command_request"),
   accessToken: z11.string().optional(),
-  commandType: z11.enum(["read_file", "list_directory", "run_tool"]),
+  commandType: KeepCommandType,
   params: z11.record(z11.string(), z11.unknown()),
   requestId: z11.string()
 });
 var KeepCommandAction = z11.object({
   action: z11.literal("keep_command"),
-  commandType: z11.enum(["read_file", "list_directory", "run_tool"]),
+  commandType: KeepCommandType,
   params: z11.record(z11.string(), z11.unknown()),
   requestId: z11.string(),
   originConnectionId: z11.string()
@@ -1849,6 +1861,59 @@ var KeepCommandResultAction = z11.object({
   result: z11.unknown().optional(),
   error: z11.string().optional()
 });
+var JupyterCellOutputAction = z11.object({
+  action: z11.literal("jupyter_cell_output"),
+  requestId: z11.string(),
+  sessionId: z11.string(),
+  jupyterSessionId: z11.string(),
+  cellIndex: z11.number(),
+  outputType: z11.enum(["stream", "execute_result", "display_data", "error"]),
+  content: z11.object({
+    text: z11.string().optional(),
+    name: z11.string().optional(),
+    // stdout, stderr for stream outputs
+    data: z11.record(z11.string(), z11.unknown()).optional(),
+    // MIME type → data for rich outputs
+    ename: z11.string().optional(),
+    // Error name
+    evalue: z11.string().optional(),
+    // Error value
+    traceback: z11.array(z11.string()).optional()
+  }),
+  executionCount: z11.number().nullable().optional(),
+  isComplete: z11.boolean()
+});
+var JupyterNotebookProgressAction = z11.object({
+  action: z11.literal("jupyter_notebook_progress"),
+  questId: z11.string(),
+  sessionId: z11.string(),
+  status: z11.enum([
+    "generating",
+    // LLM generating notebook
+    "kernel_starting",
+    // Starting Jupyter kernel
+    "executing",
+    // Executing cells
+    "cell_complete",
+    // A cell finished executing
+    "error",
+    // Cell execution error
+    "retrying",
+    // Retrying failed cell with LLM fix
+    "completed",
+    // All cells executed successfully
+    "failed"
+    // Notebook execution failed after retries
+  ]),
+  cellIndex: z11.number().optional(),
+  totalCells: z11.number().optional(),
+  currentCellCode: z11.string().optional(),
+  output: z11.unknown().optional(),
+  error: z11.string().optional(),
+  notebookPath: z11.string().optional(),
+  fabFileId: z11.string().optional()
+  // Set when notebook is saved
+});
 var TilePositionSchema = z11.object({ x: z11.number(), y: z11.number() });
 var SceneCommandSchema = z11.discriminatedUnion("type", [
   z11.object({
@@ -1985,7 +2050,8 @@ var MessageDataToServer = z11.discriminatedUnion("action", [
   CliToolRequestAction,
   KeepCommandRequestAction,
   KeepCommandResponseAction,
-  TavernSceneCommandRequestAction
+  TavernSceneCommandRequestAction,
+  JupyterCellOutputAction
 ]);
 var MessageDataToClient = z11.discriminatedUnion("action", [
   DataSubscriptionUpdateAction,
@@ -2020,6 +2086,7 @@ var MessageDataToClient = z11.discriminatedUnion("action", [
   KeepCommandResultAction,
   TavernSceneBroadcastAction,
   TavernHeartbeatLogAction,
+  JupyterNotebookProgressAction,
   DataLakeBatchProgressAction
 ]);
 
@@ -6262,6 +6329,52 @@ function getDataLakeTags(userTags, dynamicDataLakes) {
   return getAccessibleDataLakes(userTags, dynamicDataLakes).map((dl) => dl.datalakeTag);
 }
 
+// ../../b4m-core/packages/common/dist/src/constants/jupyter.js
+var ALLOWED_JUPYTER_KERNELS = [
+  "python3",
+  "python",
+  "python2",
+  "ir",
+  // R kernel
+  "julia-1.9",
+  "julia-1.10",
+  "julia"
+];
+var ALLOWED_KERNELS_SET = new Set(ALLOWED_JUPYTER_KERNELS);
+function isAllowedJupyterKernel(kernelName) {
+  return ALLOWED_KERNELS_SET.has(kernelName);
+}
+function getAllowedKernelsList() {
+  return ALLOWED_JUPYTER_KERNELS.join(", ");
+}
+function validateJupyterKernelName(kernelName) {
+  if (!kernelName || typeof kernelName !== "string") {
+    return { valid: false, error: "Kernel name is required" };
+  }
+  if (!isAllowedJupyterKernel(kernelName)) {
+    return {
+      valid: false,
+      error: `Invalid kernel: '${kernelName}'. Allowed kernels: ${getAllowedKernelsList()}`
+    };
+  }
+  return { valid: true };
+}
+function validateNotebookPath(path, requireIpynbExtension = false) {
+  if (!path || typeof path !== "string") {
+    return { valid: false, error: "Notebook path is required" };
+  }
+  if (path.includes("..") || path.includes("//")) {
+    return { valid: false, error: "Invalid notebook path: path traversal not allowed" };
+  }
+  if (/[\x00-\x1f]/.test(path)) {
+    return { valid: false, error: "Invalid notebook path: contains control characters" };
+  }
+  if (requireIpynbExtension && !path.endsWith(".ipynb")) {
+    return { valid: false, error: "Invalid notebook path: must end with .ipynb" };
+  }
+  return { valid: true };
+}
+
 // ../../b4m-core/packages/common/dist/src/llm.js
 import { z as z29 } from "zod";
 var DashboardParamsSchema = z29.object({
@@ -11892,10 +12005,13 @@ export {
   CliCompletionDoneAction,
   CliCompletionErrorAction,
   CliToolResponseAction,
+  KeepCommandType,
   KeepCommandRequestAction,
   KeepCommandAction,
   KeepCommandResponseAction,
   KeepCommandResultAction,
+  JupyterCellOutputAction,
+  JupyterNotebookProgressAction,
   TavernSceneCommandRequestAction,
   TavernSceneBroadcastAction,
   TavernHeartbeatLogAction,
@@ -12101,6 +12217,11 @@ export {
   DATA_LAKES,
   getAccessibleDataLakes,
   getDataLakeTags,
+  ALLOWED_JUPYTER_KERNELS,
+  isAllowedJupyterKernel,
+  getAllowedKernelsList,
+  validateJupyterKernelName,
+  validateNotebookPath,
   DashboardParamsSchema,
   QuestMasterParamsSchema,
   ResearchModeConfigurationSchema,

package/dist/{chunk-XACIOJZ7.js → chunk-YKQNMQX5.js}

@@ -6,12 +6,12 @@ import {
   getSettingsByNames,
   obfuscateApiKey,
   secureParameters
-} from "./chunk-KGAK226I.js";
+} from "./chunk-AWG7GGY5.js";
 import {
   ApiKeyType,
   MementoTier,
   isSupportedEmbeddingModel
-} from "./chunk-I5ZF2OVL.js";
+} from "./chunk-VWH4PFPB.js";
 
 // ../../b4m-core/packages/services/dist/src/apiKeyService/get.js
 import { z } from "zod";

package/dist/commands/doctorCommand.js

@@ -3,7 +3,7 @@ import {
   fetchLatestVersion,
   forceCheckForUpdate,
   package_default
-} from "../chunk-5UDVBQZ7.js";
+} from "../chunk-TYXGSRCJ.js";
 
 // src/commands/doctorCommand.ts
 import { execSync } from "child_process";

package/dist/commands/headlessCommand.js

@@ -36,20 +36,20 @@ import {
   isReadOnlyTool,
   loadContextFiles,
   setWebSocketToolExecutor
-} from "../chunk-SA2GRZGG.js";
+} from "../chunk-O55VX62E.js";
 import "../chunk-BDQBOLYG.js";
-import "../chunk-XACIOJZ7.js";
+import "../chunk-YKQNMQX5.js";
 import "../chunk-GQGOWACU.js";
-import "../chunk-VILQBYE6.js";
-import "../chunk-S27A7SCI.js";
-import "../chunk-KGAK226I.js";
+import "../chunk-RIFFSKKB.js";
+import "../chunk-67YAACDQ.js";
+import "../chunk-AWG7GGY5.js";
 import "../chunk-PFBYGCOW.js";
 import "../chunk-BPFEGDC7.js";
 import {
   ConfigStore,
   logger
-} from "../chunk-524RAWPN.js";
-import "../chunk-I5ZF2OVL.js";
+} from "../chunk-3JJYLK4C.js";
+import "../chunk-VWH4PFPB.js";
 import {
   DEFAULT_SANDBOX_CONFIG
 } from "../chunk-4BIBE3J7.js";

package/dist/commands/mcpCommand.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   ConfigStore
-} from "../chunk-524RAWPN.js";
-import "../chunk-I5ZF2OVL.js";
+} from "../chunk-3JJYLK4C.js";
+import "../chunk-VWH4PFPB.js";
 import "../chunk-4BIBE3J7.js";
 
 // src/commands/mcpCommand.ts

package/dist/commands/updateCommand.js

@@ -2,7 +2,7 @@
 import {
   forceCheckForUpdate,
   package_default
-} from "../chunk-5UDVBQZ7.js";
+} from "../chunk-TYXGSRCJ.js";
 
 // src/commands/updateCommand.ts
 import { execSync } from "child_process";

package/dist/{create-72N2ZGVO.js → create-3EHSR6G6.js}

@@ -2,10 +2,10 @@
 import {
   createFabFile,
   createFabFileSchema
-} from "./chunk-S27A7SCI.js";
-import "./chunk-KGAK226I.js";
+} from "./chunk-67YAACDQ.js";
+import "./chunk-AWG7GGY5.js";
 import "./chunk-PFBYGCOW.js";
-import "./chunk-I5ZF2OVL.js";
+import "./chunk-VWH4PFPB.js";
 export {
   createFabFile,
   createFabFileSchema

package/dist/index.js

@@ -46,33 +46,35 @@ import {
   setWebSocketToolExecutor,
   substituteArguments,
   warmFileCache
-} from "./chunk-SA2GRZGG.js";
+} from "./chunk-O55VX62E.js";
 import "./chunk-BDQBOLYG.js";
-import "./chunk-XACIOJZ7.js";
+import "./chunk-YKQNMQX5.js";
 import "./chunk-GQGOWACU.js";
-import "./chunk-VILQBYE6.js";
-import "./chunk-S27A7SCI.js";
+import "./chunk-RIFFSKKB.js";
+import "./chunk-67YAACDQ.js";
 import {
   OllamaBackend
-} from "./chunk-KGAK226I.js";
+} from "./chunk-AWG7GGY5.js";
 import "./chunk-PFBYGCOW.js";
 import "./chunk-BPFEGDC7.js";
 import {
   ConfigStore,
   logger
-} from "./chunk-524RAWPN.js";
+} from "./chunk-3JJYLK4C.js";
 import {
   checkForUpdate,
   package_default
-} from "./chunk-5UDVBQZ7.js";
+} from "./chunk-TYXGSRCJ.js";
 import {
   selectActiveBackgroundAgents,
   useCliStore
 } from "./chunk-G2LYCVZJ.js";
 import {
   CREDIT_DEDUCT_TRANSACTION_TYPES,
-  ChatModels
-} from "./chunk-I5ZF2OVL.js";
+  ChatModels,
+  validateJupyterKernelName,
+  validateNotebookPath
+} from "./chunk-VWH4PFPB.js";
 import "./chunk-4BIBE3J7.js";
 
 // src/index.tsx
@@ -2484,6 +2486,305 @@ var MessageBuilder = class {
   }
 };
 
+// src/utils/jupyterClient.ts
+import WebSocket from "ws";
+var JupyterClientError = class extends Error {
+  constructor(message, statusCode, response) {
+    super(message);
+    this.statusCode = statusCode;
+    this.response = response;
+    this.name = "JupyterClientError";
+  }
+};
+function validateServerUrl(url) {
+  if (!url || typeof url !== "string") {
+    throw new JupyterClientError("Server URL is required");
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new JupyterClientError(`Invalid server URL: ${url}`);
+  }
+  if (!["http:", "https:"].includes(parsed.protocol)) {
+    throw new JupyterClientError(`Invalid protocol: ${parsed.protocol}. Only http and https are allowed`);
+  }
+}
+function validateNotebookPath2(path3) {
+  const result = validateNotebookPath(path3);
+  if (!result.valid) {
+    throw new JupyterClientError(result.error || "Invalid notebook path");
+  }
+}
+function validateKernelName(name) {
+  const result = validateJupyterKernelName(name);
+  if (!result.valid) {
+    throw new JupyterClientError(result.error || "Invalid kernel name");
+  }
+}
+var JupyterClient = class {
+  constructor(config) {
+    validateServerUrl(config.serverUrl);
+    this.serverUrl = config.serverUrl.replace(/\/$/, "");
+    this.token = config.token;
+  }
+  getHeaders() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.token) {
+      headers["Authorization"] = `token ${this.token}`;
+    }
+    return headers;
+  }
+  async request(method, path3, body) {
+    const url = `${this.serverUrl}${path3}`;
+    const options = {
+      method,
+      headers: this.getHeaders()
+    };
+    if (body) {
+      options.body = JSON.stringify(body);
+    }
+    const response = await fetch(url, options);
+    if (!response.ok) {
+      let errorBody;
+      try {
+        errorBody = await response.json();
+      } catch {
+        errorBody = await response.text();
+      }
+      throw new JupyterClientError(
+        `Jupyter API error: ${response.status} ${response.statusText}`,
+        response.status,
+        errorBody
+      );
+    }
+    if (response.status === 204) {
+      return {};
+    }
+    return response.json();
+  }
+  /**
+   * Check if the Jupyter server is running and accessible
+   */
+  async checkStatus() {
+    return this.request("GET", "/api/status");
+  }
+  /**
+   * Get available kernel specifications
+   */
+  async getKernelSpecs() {
+    return this.request("GET", "/api/kernelspecs");
+  }
+  /**
+   * List all active sessions
+   */
+  async listSessions() {
+    return this.request("GET", "/api/sessions");
+  }
+  /**
+   * Start a new kernel session for a notebook
+   */
+  async startSession(notebookPath, kernelName) {
+    validateNotebookPath2(notebookPath);
+    const kernel = kernelName || "python3";
+    validateKernelName(kernel);
+    return this.request("POST", "/api/sessions", {
+      path: notebookPath,
+      type: "notebook",
+      name: notebookPath.split("/").pop() || "Untitled",
+      kernel: {
+        name: kernel
+      }
+    });
+  }
+  /**
+   * Get a session by ID
+   */
+  async getSession(sessionId) {
+    return this.request("GET", `/api/sessions/${sessionId}`);
+  }
+  /**
+   * Stop a kernel session
+   */
+  async stopSession(sessionId) {
+    await this.request("DELETE", `/api/sessions/${sessionId}`);
+  }
+  /**
+   * Get WebSocket URL for kernel channels
+   */
+  getKernelWebSocketUrl(kernelId) {
+    const httpUrl = new URL(this.serverUrl);
+    const wsProtocol = httpUrl.protocol === "https:" ? "wss:" : "ws:";
+    const wsUrl = `${wsProtocol}//${httpUrl.host}/api/kernels/${kernelId}/channels`;
+    if (this.token) {
+      return `${wsUrl}?token=${this.token}`;
+    }
+    return wsUrl;
+  }
+  /**
+   * Generate a unique message ID for Jupyter protocol
+   */
+  generateMsgId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+  }
+  /**
+   * Execute code in a kernel using the Jupyter WebSocket protocol.
+   *
+   * Connects to the kernel's channels WebSocket, sends an execute_request,
+   * and collects outputs until the kernel returns to idle state.
+   *
+   * @param kernelId - The kernel ID to execute code in
+   * @param code - The code to execute
+   * @param timeoutMs - Execution timeout in milliseconds (default: 30000)
+   */
+  async executeCell(kernelId, code, timeoutMs = 3e4) {
+    const wsUrl = this.getKernelWebSocketUrl(kernelId);
+    const msgId = this.generateMsgId();
+    return new Promise((resolve, reject) => {
+      const outputs = [];
+      let executionCount = null;
+      let hasError = false;
+      let errorInfo;
+      const ws = new WebSocket(wsUrl);
+      const timeoutHandle = setTimeout(() => {
+        cleanup();
+        reject(new JupyterClientError(`Cell execution timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      const cleanup = () => {
+        clearTimeout(timeoutHandle);
+        if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+          ws.close();
+        }
+      };
+      ws.on("error", (err) => {
+        cleanup();
+        reject(new JupyterClientError(`WebSocket error: ${err.message}`));
+      });
+      ws.on("open", () => {
+        const executeRequest = {
+          header: {
+            msg_id: msgId,
+            msg_type: "execute_request",
+            username: "b4m-cli",
+            session: this.generateMsgId(),
+            date: (/* @__PURE__ */ new Date()).toISOString(),
+            version: "5.3"
+          },
+          parent_header: {},
+          metadata: {},
+          content: {
+            code,
+            silent: false,
+            store_history: true,
+            user_expressions: {},
+            allow_stdin: false,
+            stop_on_error: true
+          },
+          buffers: [],
+          channel: "shell"
+        };
+        ws.send(JSON.stringify(executeRequest));
+      });
+      ws.on("message", (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          if (msg.parent_header?.msg_id !== msgId) {
+            return;
+          }
+          const msgType = msg.header?.msg_type || msg.msg_type;
+          switch (msgType) {
+            case "stream":
+              outputs.push({
+                output_type: "stream",
+                name: msg.content.name,
+                text: msg.content.text
+              });
+              break;
+            case "execute_result":
+              executionCount = msg.content.execution_count;
+              outputs.push({
+                output_type: "execute_result",
+                data: msg.content.data,
+                execution_count: msg.content.execution_count,
+                metadata: msg.content.metadata
+              });
+              break;
+            case "display_data":
+              outputs.push({
+                output_type: "display_data",
+                data: msg.content.data,
+                metadata: msg.content.metadata
+              });
+              break;
+            case "error":
+              hasError = true;
+              errorInfo = {
+                ename: msg.content.ename,
+                evalue: msg.content.evalue,
+                traceback: msg.content.traceback
+              };
+              outputs.push({
+                output_type: "error",
+                ename: msg.content.ename,
+                evalue: msg.content.evalue,
+                traceback: msg.content.traceback
+              });
+              break;
+            case "execute_reply":
+              if (msg.content.status === "ok" || msg.content.status === "error") {
+                if (msg.content.execution_count !== void 0) {
+                  executionCount = msg.content.execution_count;
+                }
+                cleanup();
+                resolve({
+                  success: !hasError,
+                  outputs,
+                  executionCount,
+                  error: errorInfo
+                });
+              }
+              break;
+            case "status":
+              break;
+          }
+        } catch {
+        }
+      });
+      ws.on("close", () => {
+        clearTimeout(timeoutHandle);
+      });
+    });
+  }
+  /**
+   * @deprecated Use executeCell instead. This method exists for backwards compatibility.
+   */
+  async executeCode(kernelId, code) {
+    return this.executeCell(kernelId, code);
+  }
+  /**
+   * Interrupt a running kernel
+   */
+  async interruptKernel(kernelId) {
+    await this.request("POST", `/api/kernels/${kernelId}/interrupt`);
+  }
+  /**
+   * Restart a kernel
+   */
+  async restartKernel(kernelId) {
+    return this.request("POST", `/api/kernels/${kernelId}/restart`);
+  }
+};
+function createJupyterClientFromEnv() {
+  const serverUrl = process.env.JUPYTER_SERVER_URL;
+  const token = process.env.JUPYTER_TOKEN;
+  if (!serverUrl) {
+    return null;
+  }
+  return new JupyterClient({ serverUrl, token });
+}
+
 // src/llm/NotifyingLlmBackend.ts
 var NotifyingLlmBackend = class {
   constructor(inner, backgroundManager) {
@@ -2689,6 +2990,15 @@ process.on("warning", (warning) => {
   }
   console.warn(warning);
 });
+function getRequiredJupyterClient() {
+  const client = createJupyterClientFromEnv();
+  if (!client) {
+    throw new Error(
+      "Jupyter not configured. Set JUPYTER_SERVER_URL and optionally JUPYTER_TOKEN environment variables."
+    );
+  }
+  return client;
+}
 var exitTimestamp = null;
 var EXIT_TIMEOUT_MS = 2e3;
 var usageCache = null;
@@ -2924,6 +3234,46 @@ function CliApp() {
                   result = entries.map((e) => ({ name: e.name, isDirectory: e.isDirectory() }));
                   break;
                 }
+                // Jupyter kernel commands
+                case "jupyter_get_kernelspecs": {
+                  logger.info("[Keep] Getting Jupyter kernel specs");
+                  result = await getRequiredJupyterClient().getKernelSpecs();
+                  break;
+                }
+                case "jupyter_start_kernel": {
+                  const notebookPath = params.notebookPath;
+                  const kernelName = params.kernelName;
+                  logger.info(`[Keep] Starting Jupyter kernel for: ${notebookPath}`);
+                  result = await getRequiredJupyterClient().startSession(notebookPath, kernelName);
+                  break;
+                }
+                case "jupyter_stop_kernel": {
+                  const sessionId = params.sessionId;
+                  if (!sessionId) throw new Error("Missing required param: sessionId");
+                  logger.info(`[Keep] Stopping Jupyter session: ${sessionId}`);
+                  await getRequiredJupyterClient().stopSession(sessionId);
+                  result = { success: true, sessionId };
+                  break;
+                }
+                case "jupyter_execute_cell": {
+                  const code = params.code;
+                  const kernelId = params.kernelId;
+                  const timeoutMs = params.timeoutMs || 3e4;
+                  if (!code) throw new Error("Missing required param: code");
+                  if (!kernelId) throw new Error("Missing required param: kernelId");
+                  logger.info(`[Keep] Executing cell (kernel: ${kernelId}, code length: ${code.length})`);
+                  const cellResult = await getRequiredJupyterClient().executeCell(kernelId, code, timeoutMs);
+                  logger.info(
+                    `[Keep] Cell execution ${cellResult.success ? "succeeded" : "failed"} (outputs: ${cellResult.outputs.length}, execution_count: ${cellResult.executionCount})`
+                  );
+                  result = {
+                    success: cellResult.success,
+                    outputs: cellResult.outputs,
+                    executionCount: cellResult.executionCount,
+                    error: cellResult.error
+                  };
+                  break;
+                }
                 default:
                   throw new Error(`Unknown command type: ${commandType}`);
               }

package/dist/{llmMarkdownGenerator-2NOW6PWQ.js → llmMarkdownGenerator-IJTR5Q4D.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   CurationArtifactType
-} from "./chunk-I5ZF2OVL.js";
+} from "./chunk-VWH4PFPB.js";
 
 // ../../b4m-core/packages/services/dist/src/notebookCurationService/llmMarkdownGenerator.js
 var DEFAULT_OPTIONS = {

package/dist/{markdownGenerator-4P3ZQHNH.js → markdownGenerator-HCAWT5AN.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   CurationArtifactType
-} from "./chunk-I5ZF2OVL.js";
+} from "./chunk-VWH4PFPB.js";
 
 // ../../b4m-core/packages/services/dist/src/notebookCurationService/markdownGenerator.js
 var DEFAULT_OPTIONS = {

package/dist/{mementoService-H35TY4ZN.js → mementoService-FFOGSHGY.js}

@@ -2,10 +2,10 @@
 import {
   findMostSimilarMemento,
   getRelevantMementos
-} from "./chunk-XACIOJZ7.js";
-import "./chunk-KGAK226I.js";
+} from "./chunk-YKQNMQX5.js";
+import "./chunk-AWG7GGY5.js";
 import "./chunk-PFBYGCOW.js";
-import "./chunk-I5ZF2OVL.js";
+import "./chunk-VWH4PFPB.js";
 export {
   findMostSimilarMemento,
   getRelevantMementos

package/dist/{src-NQXGURIE.js → src-FESQ52E6.js}

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import {
   ALERT_THRESHOLDS,
+  ALLOWED_JUPYTER_KERNELS,
   ALL_IMAGE_MODELS,
   ALL_IMAGE_SIZES,
   ANOMALY_THRESHOLDS,
@@ -160,10 +161,13 @@ import {
   JIRA_PROJECT_KEY_RE,
   JiraApi,
   JiraWebhookDeliveryStatus,
+  JupyterCellOutputAction,
+  JupyterNotebookProgressAction,
   KeepCommandAction,
   KeepCommandRequestAction,
   KeepCommandResponseAction,
   KeepCommandResultAction,
+  KeepCommandType,
   KnowledgeType,
   LEGACY_IMAGE_MODEL_MAP,
   LIVEOPS_TRIAGE_RESULT_VALIDATION_LIMITS,
@@ -451,6 +455,7 @@ import {
   generateAnonymousSessionId,
   generateFullManifest,
   getAccessibleDataLakes,
+  getAllowedKernelsList,
   getArtifactMimeType,
   getArtifactTypeInfo,
   getAtlassianConfig,
@@ -470,6 +475,7 @@ import {
   getWebsiteUrl,
   groupShareSchema,
   hasRateLimitInfo,
+  isAllowedJupyterKernel,
   isArtifact,
   isCommentWebhookEvent,
   isCreditHolder,
@@ -524,11 +530,13 @@ import {
   validateArtifactTitle,
   validateBaseArtifact,
   validateHtmlArtifactV2,
+  validateJupyterKernelName,
   validateLatticeEntity,
   validateLatticeModel,
   validateLatticeParsedIntent,
   validateLatticeRule,
   validateMermaidArtifactV2,
+  validateNotebookPath,
   validatePassword,
   validatePasswordServer,
   validatePythonArtifactV2,
@@ -537,9 +545,10 @@ import {
   validateReactArtifactV2,
   validateSvgArtifactV2,
   wikiMarkupToAdf
-} from "./chunk-I5ZF2OVL.js";
+} from "./chunk-VWH4PFPB.js";
 export {
   ALERT_THRESHOLDS,
+  ALLOWED_JUPYTER_KERNELS,
   ALL_IMAGE_MODELS,
   ALL_IMAGE_SIZES,
   ANOMALY_THRESHOLDS,
@@ -700,10 +709,13 @@ export {
   JIRA_PROJECT_KEY_RE,
   JiraApi,
   JiraWebhookDeliveryStatus,
+  JupyterCellOutputAction,
+  JupyterNotebookProgressAction,
   KeepCommandAction,
   KeepCommandRequestAction,
   KeepCommandResponseAction,
   KeepCommandResultAction,
+  KeepCommandType,
   KnowledgeType,
   LEGACY_IMAGE_MODEL_MAP,
   LIVEOPS_TRIAGE_RESULT_VALIDATION_LIMITS,
@@ -992,6 +1004,7 @@ export {
   generateAnonymousSessionId,
   generateFullManifest,
   getAccessibleDataLakes,
+  getAllowedKernelsList,
   getArtifactMimeType,
   getArtifactTypeInfo,
   getAtlassianConfig,
@@ -1011,6 +1024,7 @@ export {
   getWebsiteUrl,
   groupShareSchema,
   hasRateLimitInfo,
+  isAllowedJupyterKernel,
   isArtifact,
   isCommentWebhookEvent,
   isCreditHolder,
@@ -1065,11 +1079,13 @@ export {
   validateArtifactTitle,
   validateBaseArtifact,
   validateHtmlArtifactV2,
+  validateJupyterKernelName,
   validateLatticeEntity,
   validateLatticeModel,
   validateLatticeParsedIntent,
   validateLatticeRule,
   validateMermaidArtifactV2,
+  validateNotebookPath,
   validatePassword,
   validatePasswordServer,
   validatePythonArtifactV2,

package/dist/{src-2BN3ALZD.js → src-SXD7R5WA.js}

@@ -143,7 +143,7 @@ import {
   validateUrlForFetch,
   warmUpSettingsCache,
   withRetry
-} from "./chunk-KGAK226I.js";
+} from "./chunk-AWG7GGY5.js";
 import {
   Logger,
   NotificationDeduplicator,
@@ -156,7 +156,7 @@ import {
   buildRateLimitLogEntry,
   isNearLimit,
   parseRateLimitHeaders
-} from "./chunk-I5ZF2OVL.js";
+} from "./chunk-VWH4PFPB.js";
 export {
   AIVideoService,
   AWSBackend,

package/dist/{subtractCredits-XRG2QRZG.js → subtractCredits-PATASZEG.js}

@@ -2,10 +2,10 @@
 import {
   SubtractCreditsSchema,
   subtractCredits
-} from "./chunk-VILQBYE6.js";
-import "./chunk-KGAK226I.js";
+} from "./chunk-RIFFSKKB.js";
+import "./chunk-AWG7GGY5.js";
 import "./chunk-PFBYGCOW.js";
-import "./chunk-I5ZF2OVL.js";
+import "./chunk-VWH4PFPB.js";
 export {
   SubtractCreditsSchema,
   subtractCredits

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bike4mind/cli",
-  "version": "0.2.56",
+  "version": "0.2.57-feat-jupyter-interoperability-roadmap.21458+b5aabe927",
   "type": "module",
   "description": "Interactive CLI tool for Bike4Mind with ReAct agents",
   "license": "UNLICENSED",
@@ -115,11 +115,11 @@
     "zustand": "^4.5.4"
   },
   "devDependencies": {
-    "@bike4mind/agents": "0.2.1",
-    "@bike4mind/common": "2.70.1",
-    "@bike4mind/mcp": "1.33.15",
-    "@bike4mind/services": "2.64.3",
-    "@bike4mind/utils": "2.15.9",
+    "@bike4mind/agents": "0.2.2-feat-jupyter-interoperability-roadmap.21458+b5aabe927",
+    "@bike4mind/common": "2.70.2-feat-jupyter-interoperability-roadmap.21458+b5aabe927",
+    "@bike4mind/mcp": "1.33.16-feat-jupyter-interoperability-roadmap.21458+b5aabe927",
+    "@bike4mind/services": "2.64.4-feat-jupyter-interoperability-roadmap.21458+b5aabe927",
+    "@bike4mind/utils": "2.15.10-feat-jupyter-interoperability-roadmap.21458+b5aabe927",
     "@types/better-sqlite3": "^7.6.13",
     "@types/jsonwebtoken": "^9.0.4",
     "@types/node": "^22.9.0",
@@ -136,5 +136,5 @@
   "optionalDependencies": {
     "@vscode/ripgrep": "^1.17.1"
   },
-  "gitHead": "bf6c3f4e7997e0ab0796c64ccd6b46d6d1fce954"
+  "gitHead": "b5aabe927ab8e991be795c9a1e998f921eaf3452"
 }