@bike4mind/cli 0.1.0

package/README.md

@@ -0,0 +1,246 @@
+# Bike4Mind CLI
+
+Interactive command-line interface for Bike4Mind with ReAct agents.
+
+## Features
+
+- 🤖 ReAct agent with reasoning and tool use
+- 💬 Interactive chat interface
+- 💾 Session persistence
+- 🛠️ B4M tools + MCP integration
+- 🎨 Rich terminal UI with Ink
+
+## Installation
+
+### From NPM (Recommended)
+
+Install globally:
+
+```bash
+npm install -g @bike4mind/cli
+```
+
+Or run without installing:
+
+```bash
+npx @bike4mind/cli
+```
+
+### From Source (Development)
+
+From the project root:
+
+```bash
+pnpm install
+```
+
+## Development
+
+```bash
+# Run in development mode
+cd apps/cli
+pnpm dev
+
+# Build for production
+pnpm build
+
+# Type check
+pnpm typecheck
+```
+
+## Usage
+
+### Start Interactive Session
+
+```bash
+b4m
+```
+
+### Quick Query
+
+```bash
+b4m "What's the weather in San Francisco?"
+```
+
+### With Options
+
+```bash
+# Use specific model
+b4m --model claude-3-5-haiku-20241022
+
+# Load saved session
+b4m --session my-project
+
+# Debug mode
+b4m --debug
+```
+
+## Commands
+
+While in interactive mode:
+
+- `/help` - Show help
+- `/exit` - Exit CLI
+- `/save <name>` - Save current session
+- `/sessions` - List saved sessions
+- `/config` - Show configuration
+- `/models` - List available models
+- `/tools` - List available tools
+
+## Configuration
+
+Configuration is stored in `~/.bike4mind/config.json`
+
+### Required: LLM API Keys
+
+Set at least one LLM API key in `~/.bike4mind/config.json`:
+
+```json
+{
+  "apiKeys": {
+    "anthropic": "sk-ant-...",
+    "openai": "sk-..."
+  },
+  "defaultModel": "claude-3-5-sonnet-20241022",
+  "preferences": {
+    "maxTokens": 4096,
+    "temperature": 0.7,
+    "autoSave": true
+  },
+  "mcpServers": []
+}
+```
+
+### Optional: Tool API Keys
+
+Some tools require additional API keys. Add them to your config file:
+
+```json
+{
+  "apiKeys": {
+    "anthropic": "sk-ant-..."
+  },
+  "toolApiKeys": {
+    "openweather": "your-openweather-key",
+    "serper": "your-serper-key"
+  },
+  "defaultModel": "claude-3-5-sonnet-20241022",
+  "preferences": {
+    "maxTokens": 4096,
+    "temperature": 0.7,
+    "autoSave": true
+  }
+}
+```
+
+Or use environment variables (config takes precedence):
+
+```bash
+export OPENWEATHER_API_KEY="your-key-here"
+export SERPER_API_KEY="your-key-here"
+```
+
+**Available tools**:
+- ✅ `dice_roll` - No API key needed
+- ✅ `math_evaluate` - No API key needed
+- ✅ `current_datetime` - No API key needed
+- ✅ `prompt_enhancement` - No API key needed
+- 🔑 `weather_info` - Requires `toolApiKeys.openweather`
+- 🔑 `web_search` - Requires `toolApiKeys.serper`
+- 🔑 `deep_research` - Requires `toolApiKeys.serper`
+
+**Get API keys**:
+- OpenWeather API: https://openweathermap.org/api
+- Serper API: https://serper.dev/
+
+### Optional: MCP Servers
+
+MCP (Model Context Protocol) servers provide additional tools and capabilities. Configure them in your config file:
+
+```json
+{
+  "apiKeys": {
+    "anthropic": "sk-ant-..."
+  },
+  "mcpServers": [
+    {
+      "name": "github",
+      "command": "node",
+      "args": ["path/to/mcp/server.js"],
+      "env": {
+        "GITHUB_ACCESS_TOKEN": "ghp_..."
+      },
+      "enabled": true
+    }
+  ]
+}
+```
+
+**Available MCP Servers:**
+- 🔧 **GitHub** - Repository management, issues, PRs (requires `GITHUB_ACCESS_TOKEN`)
+- 🔧 **LinkedIn** - Post management, analytics (requires `LINKEDIN_ACCESS_TOKEN`, `COMPANY_NAME`)
+- 🔧 **Atlassian** - Jira/Confluence integration (requires `ATLASSIAN_ACCESS_TOKEN`, `ATLASSIAN_CLOUD_ID`, `ATLASSIAN_SITE_URL`)
+
+**Note:** MCP servers must be built and available in the `b4m-core/packages/mcp/dist/src/` directory. The CLI will automatically find them if you're running from the monorepo.
+
+## Session Storage
+
+Sessions are saved to `~/.bike4mind/sessions/`
+
+Each session includes:
+- Full conversation history
+- Token usage tracking
+- Agent reasoning steps
+- Metadata
+
+## Architecture
+
+```
+apps/cli/
+├── src/
+│   ├── components/       # Ink React components
+│   │   ├── App.tsx
+│   │   ├── StatusBar.tsx
+│   │   ├── MessageList.tsx
+│   │   ├── InputPrompt.tsx
+│   │   └── ThoughtStream.tsx
+│   ├── storage/          # Local persistence
+│   │   ├── SessionStore.ts
+│   │   └── ConfigStore.ts
+│   └── index.tsx         # Main entry point
+└── bin/
+    └── bike4mind-cli.js  # Executable
+```
+
+## Dependencies
+
+- `@bike4mind/agents` - ReAct agent implementation
+- `@bike4mind/services` - B4M tools
+- `@bike4mind/mcp` - MCP integration
+- `@bike4mind/utils` - LLM backends
+- `ink` - React for CLIs
+- `commander` - CLI argument parsing
+- `lowdb` - Local storage
+
+## Development Status
+
+Current implementation includes:
+
+✅ Basic CLI structure
+✅ ReAct agent integration
+✅ Session persistence
+✅ Configuration management
+✅ Interactive UI with Ink
+✅ B4M tools integration
+✅ MCP tools support
+
+Coming soon:
+
+⏳ Advanced UI features (streaming visualization, syntax highlighting)
+⏳ Export functionality (sessions to markdown/JSON)
+⏳ Session search and management
+⏳ Tool execution monitoring
+
+## License
+
+Private - Bike4Mind

package/bin/bike4mind-cli.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+/* eslint-disable */
+
+// This is the executable entry point for the CLI
+// In development, it will use tsx to run the TypeScript directly
+// In production, it will run the compiled JavaScript
+
+// Suppress punycode deprecation warning from dependencies
+// This is a known issue with older npm packages using Node's built-in punycode
+process.removeAllListeners('warning');
+process.on('warning', (warning) => {
+  // Only suppress punycode deprecation warnings
+  if (warning.name === 'DeprecationWarning' && warning.message.includes('punycode')) {
+    return;
+  }
+  // Show all other warnings
+  console.warn(warning);
+});
+
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const require = createRequire(import.meta.url);
+
+// Auto-detect environment: prefer production mode when dist exists
+const distPath = join(__dirname, '../dist/index.js');
+const srcPath = join(__dirname, '../src/index.tsx');
+const hasSource = existsSync(srcPath);
+const hasDist = existsSync(distPath);
+
+// Development mode ONLY when:
+// 1. NODE_ENV is explicitly 'development', OR
+// 2. dist doesn't exist but source does (fallback)
+// Otherwise: use production mode (this is what npm users will run)
+const isDev = process.env.NODE_ENV === 'development' ||
+              (!hasDist && hasSource);
+
+if (isDev) {
+  // Show dev mode indicator for developers
+  console.log('🔧 Running in development mode (using TypeScript source)\n');
+  // Development: use tsx to run TypeScript
+  try {
+    const { register } = require('tsx/esm/api');
+    register();
+
+    // Import and run the main app
+    await import(join(__dirname, '../src/index.tsx'));
+  } catch (error) {
+    console.error('Failed to start CLI in development mode:', error);
+    console.error('\nTry running: pnpm install');
+    process.exit(1);
+  }
+} else {
+  // Production: run compiled JavaScript
+  try {
+    await import(join(__dirname, '../dist/index.js'));
+  } catch (error) {
+    console.error('Failed to start CLI:', error);
+    console.error('\nTry running: pnpm build');
+    process.exit(1);
+  }
+}

package/dist/artifactExtractor-QN34RFDM.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+import {
+  CurationArtifactType
+} from "./chunk-MKO2KCCS.js";
+import "./chunk-PDX44BCA.js";
+
+// ../../b4m-core/packages/services/dist/src/notebookCurationService/artifactExtractor.js
+var ARTIFACT_TAG_REGEX = /<artifact\s+(.*?)>([\s\S]*?)<\/artifact>/gi;
+var ATTRIBUTE_REGEX = /(\w+)=["']([^"']*?)["']/g;
+var CODE_BLOCK_REGEX = /```(\w+)?\s*([\s\S]*?)```/g;
+function extractArtifactsFromMessage(message, options) {
+  const artifacts = [];
+  const messageId = message.id || message._id?.toString() || "unknown";
+  const timestamp = message.timestamp ? new Date(message.timestamp) : /* @__PURE__ */ new Date();
+  const textContent = [
+    message.prompt || "",
+    message.reply || "",
+    ...message.replies || [],
+    message.questMasterReply || ""
+  ].filter(Boolean).join("\n\n");
+  if (!textContent) {
+    return artifacts;
+  }
+  if (options.includeCode || options.includeDiagrams || options.includeDataViz) {
+    const tagArtifacts = extractArtifactTags(textContent, messageId, timestamp);
+    artifacts.push(...tagArtifacts);
+  }
+  if (options.includeCode) {
+    const codeArtifacts = extractCodeBlocks(textContent, messageId, timestamp);
+    artifacts.push(...codeArtifacts);
+  }
+  if (options.includeQuestMaster && message.questMasterPlanId) {
+    artifacts.push({
+      type: CurationArtifactType.QUESTMASTER_PLAN,
+      content: message.questMasterPlanId,
+      messageId,
+      timestamp,
+      metadata: {
+        planId: message.questMasterPlanId
+      }
+    });
+  }
+  if (options.includeResearch && message.deepResearchState) {
+    const research = message.deepResearchState;
+    artifacts.push({
+      type: CurationArtifactType.DEEP_RESEARCH,
+      content: JSON.stringify(research, null, 2),
+      messageId,
+      timestamp,
+      metadata: {
+        findingsCount: research.findings?.length || 0,
+        sourcesCount: research.sources?.length || 0,
+        depth: research.depth,
+        completed: research.completed,
+        topic: research.topic
+      }
+    });
+  }
+  if (options.includeImages && message.images && message.images.length > 0) {
+    message.images.forEach((imagePath, index) => {
+      artifacts.push({
+        type: CurationArtifactType.IMAGE,
+        content: imagePath,
+        messageId,
+        timestamp,
+        metadata: {
+          index,
+          path: imagePath
+        }
+      });
+    });
+  }
+  return artifacts;
+}
+function extractArtifactTags(content, messageId, timestamp) {
+  const artifacts = [];
+  let match;
+  ARTIFACT_TAG_REGEX.lastIndex = 0;
+  while ((match = ARTIFACT_TAG_REGEX.exec(content)) !== null) {
+    const [, attributesString, artifactContent] = match;
+    const attributes = {};
+    let attrMatch;
+    ATTRIBUTE_REGEX.lastIndex = 0;
+    while ((attrMatch = ATTRIBUTE_REGEX.exec(attributesString)) !== null) {
+      const [, key, value] = attrMatch;
+      attributes[key] = value;
+    }
+    const mimeType = attributes.type || "";
+    const title = attributes.title || "Untitled";
+    const language = attributes.language;
+    const identifier = attributes.identifier;
+    const artifactType = mapMimeTypeToArtifactType(mimeType);
+    if (artifactType) {
+      artifacts.push({
+        type: artifactType,
+        content: artifactContent.trim(),
+        language: language || inferLanguageFromType(artifactType),
+        messageId,
+        timestamp,
+        metadata: {
+          title,
+          identifier,
+          mimeType
+        }
+      });
+    }
+  }
+  return artifacts;
+}
+function extractCodeBlocks(content, messageId, timestamp) {
+  const artifacts = [];
+  let match;
+  CODE_BLOCK_REGEX.lastIndex = 0;
+  while ((match = CODE_BLOCK_REGEX.exec(content)) !== null) {
+    const [, language, codeContent] = match;
+    if (!codeContent || !codeContent.trim()) {
+      continue;
+    }
+    const lineCount = codeContent.trim().split("\n").length;
+    if (lineCount < 3) {
+      continue;
+    }
+    const lang = (language || "text").toLowerCase();
+    let artifactType;
+    if (["mermaid"].includes(lang)) {
+      artifactType = CurationArtifactType.MERMAID;
+    } else if (["recharts"].includes(lang)) {
+      artifactType = CurationArtifactType.RECHARTS;
+    } else if (["svg", "xml"].includes(lang)) {
+      artifactType = CurationArtifactType.SVG;
+    } else if (["html", "htm"].includes(lang)) {
+      artifactType = CurationArtifactType.HTML;
+    } else if (["tsx", "jsx", "javascript", "typescript", "react"].includes(lang) && (codeContent.includes("useState") || codeContent.includes("useEffect") || codeContent.includes("export default"))) {
+      artifactType = CurationArtifactType.REACT;
+    } else {
+      artifactType = CurationArtifactType.CODE;
+    }
+    artifacts.push({
+      type: artifactType,
+      content: codeContent.trim(),
+      language: lang || "text",
+      messageId,
+      timestamp,
+      metadata: {
+        lineCount
+      }
+    });
+  }
+  return artifacts;
+}
+function mapMimeTypeToArtifactType(mimeType) {
+  const mimeMap = {
+    "application/vnd.ant.react": CurationArtifactType.REACT,
+    "text/html": CurationArtifactType.HTML,
+    "image/svg+xml": CurationArtifactType.SVG,
+    "application/vnd.ant.mermaid": CurationArtifactType.MERMAID,
+    "application/vnd.ant.recharts": CurationArtifactType.RECHARTS,
+    "application/vnd.ant.code": CurationArtifactType.CODE,
+    "text/x.python": CurationArtifactType.CODE,
+    "text/x.typescript": CurationArtifactType.CODE,
+    "text/x.javascript": CurationArtifactType.CODE
+  };
+  return mimeMap[mimeType] || null;
+}
+function inferLanguageFromType(type) {
+  const languageMap = {
+    [CurationArtifactType.CODE]: "typescript",
+    [CurationArtifactType.REACT]: "tsx",
+    [CurationArtifactType.MERMAID]: "mermaid",
+    [CurationArtifactType.RECHARTS]: "json",
+    [CurationArtifactType.SVG]: "xml",
+    [CurationArtifactType.HTML]: "html",
+    [CurationArtifactType.QUESTMASTER_PLAN]: void 0,
+    [CurationArtifactType.DEEP_RESEARCH]: "json",
+    [CurationArtifactType.IMAGE]: void 0
+  };
+  return languageMap[type];
+}
+export {
+  extractArtifactsFromMessage
+};

package/dist/chunk-BDQBOLYG.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+// ../../b4m-core/packages/services/dist/src/mfaService/utils.js
+import speakeasy from "speakeasy";
+import QRCode from "qrcode";
+var originalEmitWarning = process.emitWarning;
+process.emitWarning = (warning, name) => {
+  if (name === "DeprecationWarning" && warning?.toString().includes("Buffer")) {
+    return;
+  }
+  return originalEmitWarning.call(process, warning, name);
+};
+process.emitWarning = originalEmitWarning;
+async function generateTOTPSetup(userEmail, appName = "Bike4Mind") {
+  const secret = speakeasy.generateSecret({ name: `${appName} (${userEmail})` });
+  const qrCodeUrl = await QRCode.toDataURL(secret.otpauth_url);
+  return {
+    secret: secret.base32,
+    qrCodeUrl,
+    manualEntryKey: secret.base32
+  };
+}
+function verifyTOTPToken(secret, token, window = 1) {
+  return speakeasy.totp.verify({
+    secret,
+    encoding: "base32",
+    token,
+    window
+    // Allow ±30 seconds for clock drift (industry standard)
+  });
+}
+function generateBackupCodes(count = 10) {
+  return Array.from({ length: count }, () => {
+    const secret = speakeasy.generateSecret({ length: 20 });
+    return secret.base32.substring(0, 10).toUpperCase();
+  });
+}
+function verifyBackupCode(userBackupCodes, providedCode) {
+  if (!userBackupCodes || !providedCode) {
+    return { isValid: false };
+  }
+  const cleanProvidedCode = providedCode.trim().toUpperCase();
+  const idx = userBackupCodes.findIndex((code) => {
+    const cleanStoredCode = code.trim().toUpperCase();
+    return cleanStoredCode === cleanProvidedCode;
+  });
+  if (idx !== -1) {
+    return { isValid: true, usedBackupCode: userBackupCodes[idx] };
+  }
+  return { isValid: false };
+}
+function userRequiresMFA(user, enforceMFASetting) {
+  return enforceMFASetting;
+}
+function userHasMFAConfigured(user) {
+  return !!(user.mfa && user.mfa.totpEnabled && user.mfa.totpSecret);
+}
+var MAX_FAILED_ATTEMPTS = 3;
+var LOCKOUT_DURATION_MS = 15 * 60 * 1e3;
+var ATTEMPT_RESET_WINDOW_MS = 60 * 60 * 1e3;
+function isUserLockedOut(user) {
+  if (!user.mfa?.lockedUntil)
+    return false;
+  return /* @__PURE__ */ new Date() < new Date(user.mfa.lockedUntil);
+}
+function getLockoutTimeRemaining(user) {
+  if (!user.mfa?.lockedUntil)
+    return 0;
+  const remaining = new Date(user.mfa.lockedUntil).getTime() - Date.now();
+  return Math.max(0, Math.ceil(remaining / (60 * 1e3)));
+}
+function shouldResetFailedAttempts(user) {
+  if (!user.mfa?.lastFailedAttempt)
+    return false;
+  const timeSinceLastFailure = Date.now() - new Date(user.mfa.lastFailedAttempt).getTime();
+  return timeSinceLastFailure > ATTEMPT_RESET_WINDOW_MS;
+}
+function recordFailedAttempt(user) {
+  const currentAttempts = shouldResetFailedAttempts(user) ? 0 : user.mfa?.failedAttempts || 0;
+  const newAttempts = currentAttempts + 1;
+  const now = /* @__PURE__ */ new Date();
+  const updatedMFA = { ...user.mfa };
+  updatedMFA.failedAttempts = newAttempts;
+  updatedMFA.lastFailedAttempt = now;
+  if (newAttempts >= MAX_FAILED_ATTEMPTS) {
+    updatedMFA.lockedUntil = new Date(Date.now() + LOCKOUT_DURATION_MS);
+  }
+  return updatedMFA;
+}
+function clearFailedAttempts(user) {
+  if (!user.mfa)
+    return null;
+  const updatedMFA = { ...user.mfa };
+  updatedMFA.failedAttempts = 0;
+  updatedMFA.lastFailedAttempt = void 0;
+  updatedMFA.lockedUntil = void 0;
+  return updatedMFA;
+}
+function userEligibleForMFA(user) {
+  return true;
+}
+function userCanDisableMFA(user, enforceMFASetting) {
+  return !enforceMFASetting;
+}
+
+export {
+  generateTOTPSetup,
+  verifyTOTPToken,
+  generateBackupCodes,
+  verifyBackupCode,
+  userRequiresMFA,
+  userHasMFAConfigured,
+  isUserLockedOut,
+  getLockoutTimeRemaining,
+  shouldResetFailedAttempts,
+  recordFailedAttempt,
+  clearFailedAttempts,
+  userEligibleForMFA,
+  userCanDisableMFA
+};