@geminilight/mindos 0.5.21 → 0.5.22

package/app/lib/core/search.ts

@@ -1,16 +1,31 @@
 import fs from 'fs';
 import path from 'path';
-import { resolveSafe } from './security';
 import { collectAllFiles } from './tree';
 import { readFile } from './fs-ops';
+import { SearchIndex } from './search-index';
 import type { SearchResult, SearchOptions } from './types';
 
+/**
+ * Module-level search index singleton.
+ * Lazily built on first search, invalidated by `invalidateSearchIndex()`.
+ */
+const searchIndex = new SearchIndex();
+
+/** Invalidate the core search index. Called from `lib/fs.ts` on write operations. */
+export function invalidateSearchIndex(): void {
+  searchIndex.invalidate();
+}
+
 /**
  * Core literal search — used by MCP tools via REST API.
  *
  * This is a **case-insensitive literal string match** with occurrence-density scoring.
  * It supports scope, file_type, and modified_after filters that MCP tools expose.
  *
+ * Performance: uses an in-memory inverted index to narrow the candidate file set
+ * before doing full-text scanning. The index is built lazily on the first query
+ * and invalidated on any write operation.
+ *
  * NOTE: The App also has a separate Fuse.js fuzzy search in `lib/fs.ts` for the
  * browser `⌘K` search overlay. The two coexist intentionally:
  * - Core search (here): exact literal match, supports filters, used by MCP/API
@@ -20,6 +35,15 @@ export function searchFiles(mindRoot: string, query: string, opts: SearchOptions
   if (!query.trim()) return [];
   const { limit = 20, scope, file_type = 'all', modified_after } = opts;
 
+  // Ensure search index is built for this mindRoot
+  if (!searchIndex.isBuiltFor(mindRoot)) {
+    searchIndex.rebuild(mindRoot);
+  }
+
+  // Use index to get candidate files (or null if index unavailable → full scan)
+  const candidates = searchIndex.getCandidates(query);
+  const candidateSet = candidates ? new Set(candidates) : null;
+
   let allFiles = collectAllFiles(mindRoot);
 
   // Filter by scope (directory prefix)
@@ -34,6 +58,11 @@ export function searchFiles(mindRoot: string, query: string, opts: SearchOptions
     allFiles = allFiles.filter(f => f.endsWith(ext));
   }
 
+  // Narrow by index candidates (if available)
+  if (candidateSet) {
+    allFiles = allFiles.filter(f => candidateSet.has(f));
+  }
+
   // Filter by modification time
   let mtimeThreshold = 0;
   if (modified_after) {

package/app/lib/core/security.ts

@@ -1,11 +1,12 @@
 import path from 'path';
+import { MindOSError, ErrorCodes } from '@/lib/errors';
 
 /**
  * Asserts that a resolved path is within the given root.
  */
 export function assertWithinRoot(resolved: string, root: string): void {
   if (!resolved.startsWith(root + path.sep) && resolved !== root) {
-    throw new Error('Access denied: path outside MIND_ROOT');
+    throw new MindOSError(ErrorCodes.PATH_OUTSIDE_ROOT, 'Access denied: path outside MIND_ROOT', { resolved, root });
   }
 }
 
@@ -35,9 +36,11 @@ export function isRootProtected(filePath: string): boolean {
  */
 export function assertNotProtected(filePath: string, operation: string): void {
   if (isRootProtected(filePath)) {
-    throw new Error(
+    throw new MindOSError(
+      ErrorCodes.PROTECTED_FILE,
       `Protected file: root "${filePath}" cannot be ${operation} via MCP. ` +
-      `This is a system kernel file (§7 of INSTRUCTION.md). Edit it manually or use a dedicated confirmation workflow.`
+      `This is a system kernel file (§7 of INSTRUCTION.md). Edit it manually or use a dedicated confirmation workflow.`,
+      { filePath, operation },
     );
   }
 }

package/app/lib/errors.ts

@@ -0,0 +1,108 @@
+import { NextResponse } from 'next/server';
+
+/**
+ * Centralized error class for MindOS backend business logic.
+ *
+ * Every throw in `lib/core/` should use this class so that:
+ * 1. API routes can detect it in catch blocks and return structured JSON.
+ * 2. Callers can switch on `code` for programmatic handling.
+ * 3. `userMessage` provides a translatable, user-safe description.
+ */
+export class MindOSError extends Error {
+  constructor(
+    public code: ErrorCode,
+    message: string,
+    public context?: Record<string, unknown>,
+    public userMessage?: string,
+  ) {
+    super(message);
+    this.name = 'MindOSError';
+  }
+}
+
+export const ErrorCodes = {
+  // File operations
+  FILE_NOT_FOUND: 'FILE_NOT_FOUND',
+  FILE_ALREADY_EXISTS: 'FILE_ALREADY_EXISTS',
+  PATH_OUTSIDE_ROOT: 'PATH_OUTSIDE_ROOT',
+  PROTECTED_FILE: 'PROTECTED_FILE',
+  INVALID_PATH: 'INVALID_PATH',
+  INVALID_RANGE: 'INVALID_RANGE',
+  HEADING_NOT_FOUND: 'HEADING_NOT_FOUND',
+  INVALID_FILE_TYPE: 'INVALID_FILE_TYPE',
+  // API
+  INVALID_REQUEST: 'INVALID_REQUEST',
+  MODEL_INIT_FAILED: 'MODEL_INIT_FAILED',
+  // Generic
+  INTERNAL_ERROR: 'INTERNAL_ERROR',
+  PERMISSION_DENIED: 'PERMISSION_DENIED',
+} as const;
+
+export type ErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes];
+
+/** Standardized API error response envelope. */
+export interface ApiErrorResponse {
+  ok: false;
+  error: {
+    code: string;
+    message: string;
+  };
+}
+
+/** Extract a human-readable message from an unknown thrown value. */
+export function toErrorMessage(err: unknown): string {
+  if (err instanceof Error) return err.message;
+  if (typeof err === 'string') return err;
+  return String(err);
+}
+
+/** Map an ErrorCode to an HTTP status code. */
+function mapCodeToStatus(code: ErrorCode): number {
+  switch (code) {
+    case ErrorCodes.FILE_NOT_FOUND:
+    case ErrorCodes.HEADING_NOT_FOUND:
+      return 404;
+    case ErrorCodes.FILE_ALREADY_EXISTS:
+      return 409;
+    case ErrorCodes.PATH_OUTSIDE_ROOT:
+    case ErrorCodes.PROTECTED_FILE:
+    case ErrorCodes.PERMISSION_DENIED:
+      return 403;
+    case ErrorCodes.INVALID_PATH:
+    case ErrorCodes.INVALID_RANGE:
+    case ErrorCodes.INVALID_FILE_TYPE:
+    case ErrorCodes.INVALID_REQUEST:
+      return 400;
+    case ErrorCodes.MODEL_INIT_FAILED:
+    case ErrorCodes.INTERNAL_ERROR:
+    default:
+      return 500;
+  }
+}
+
+/**
+ * Build a NextResponse with the standard `{ ok, error }` envelope.
+ *
+ * If `status` is omitted it is derived from the error code.
+ */
+export function apiError(code: ErrorCode, message: string, status?: number): NextResponse<ApiErrorResponse> {
+  const effectiveStatus = status ?? mapCodeToStatus(code);
+  return NextResponse.json({ ok: false as const, error: { code, message } }, { status: effectiveStatus });
+}
+
+/**
+ * Convenience: catch an unknown error and return a structured API response.
+ *
+ * Usage in route handlers:
+ * ```ts
+ * catch (err) {
+ *   return handleRouteError(err);
+ * }
+ * ```
+ */
+export function handleRouteError(err: unknown): NextResponse<ApiErrorResponse> {
+  if (err instanceof MindOSError) {
+    return apiError(err.code, err.message);
+  }
+  return apiError(ErrorCodes.INTERNAL_ERROR, 'Internal server error', 500);
+}

package/app/lib/fs.ts

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import Fuse, { FuseResultMatch } from 'fuse.js';
+import { MindOSError, ErrorCodes } from '@/lib/errors';
 import {
   readFile as coreReadFile,
   writeFile as coreWriteFile,
@@ -19,6 +20,7 @@ import {
   isGitRepo as coreIsGitRepo,
   gitLog as coreGitLog,
   gitShowFile as coreGitShowFile,
+  invalidateSearchIndex,
 } from './core';
 import { FileNode } from './core/types';
 import { SearchMatch } from './types';
@@ -53,6 +55,7 @@ function isCacheValid(): boolean {
 export function invalidateCache(): void {
   _cache = null;
   _searchIndex = null;
+  invalidateSearchIndex();
 }
 
 function ensureCache(): FileTreeCache {
@@ -266,9 +269,9 @@ export function updateLines(filePath: string, startIndex: number, endIndex: numb
 
 export function deleteLines(filePath: string, startIndex: number, endIndex: number): void {
   const existing = readLines(filePath);
-  if (startIndex < 0 || endIndex < 0) throw new Error('Invalid line index: indices must be >= 0');
-  if (startIndex > endIndex) throw new Error(`Invalid range: start (${startIndex}) > end (${endIndex})`);
-  if (startIndex >= existing.length) throw new Error(`Invalid line index: start (${startIndex}) >= total lines (${existing.length})`);
+  if (startIndex < 0 || endIndex < 0) throw new MindOSError(ErrorCodes.INVALID_RANGE, 'Invalid line index: indices must be >= 0', { startIndex, endIndex });
+  if (startIndex > endIndex) throw new MindOSError(ErrorCodes.INVALID_RANGE, `Invalid range: start (${startIndex}) > end (${endIndex})`, { startIndex, endIndex });
+  if (startIndex >= existing.length) throw new MindOSError(ErrorCodes.INVALID_RANGE, `Invalid line index: start (${startIndex}) >= total lines (${existing.length})`, { startIndex, totalLines: existing.length });
   existing.splice(startIndex, endIndex - startIndex + 1);
   saveFileContent(filePath, existing.join('\n'));
 }

package/app/lib/i18n-en.ts

@@ -104,7 +104,7 @@ export const en = {
   },
   settings: {
     title: 'Settings',
-    tabs: { ai: 'AI', appearance: 'Appearance', knowledge: 'Knowledge Base', sync: 'Sync', mcp: 'MCP', plugins: 'Plugins', shortcuts: 'Shortcuts' },
+    tabs: { ai: 'AI', appearance: 'Appearance', knowledge: 'Knowledge Base', sync: 'Sync', mcp: 'MCP', plugins: 'Plugins', shortcuts: 'Shortcuts', monitoring: 'Monitoring', agents: 'Agents' },
     ai: {
       provider: 'Provider',
       model: 'Model',
@@ -262,6 +262,49 @@ export const en = {
       configureFor: 'Configure for',
       configPath: 'Config path',
     },
+    monitoring: {
+      system: 'System',
+      heapMemory: 'Heap Memory',
+      rss: 'RSS',
+      uptime: 'Uptime',
+      nodeVersion: 'Node',
+      application: 'Application',
+      requests: 'Requests',
+      toolCalls: 'Tool Calls',
+      avgResponse: 'Avg Response',
+      tokens: 'Tokens',
+      errors: 'Errors',
+      knowledgeBase: 'Knowledge Base',
+      files: 'Files',
+      totalSize: 'Total Size',
+      rootPath: 'Root',
+      mcpStatus: 'Status',
+      mcpRunning: 'Running',
+      mcpStopped: 'Stopped',
+      mcpPort: 'Port',
+      autoRefresh: 'Auto-refresh every 5s',
+      fetchError: 'Failed to load monitoring data',
+    },
+    agents: {
+      mcpServer: 'MCP Server',
+      running: 'Running',
+      stopped: 'Not running',
+      onPort: (port: number) => `on :${port}`,
+      refresh: 'Refresh',
+      refreshing: 'Refreshing...',
+      connected: 'Connected',
+      connectedCount: (n: number) => `Connected (${n})`,
+      detectedNotConfigured: 'Detected but not configured',
+      detectedCount: (n: number) => `Detected but not configured (${n})`,
+      notDetected: 'Not Detected',
+      notDetectedCount: (n: number) => `Not Detected (${n})`,
+      showAll: 'Show all',
+      hideAll: 'Hide',
+      connect: 'Connect',
+      noAgents: 'No agents detected on this machine.',
+      fetchError: 'Failed to load agent data',
+      autoRefresh: 'Auto-refresh every 30s',
+    },
     save: 'Save',
     saved: 'Saved',
     saveFailed: 'Save failed',

package/app/lib/i18n-zh.ts

@@ -129,7 +129,7 @@ export const zh = {
   },
   settings: {
     title: '设置',
-    tabs: { ai: 'AI', appearance: '外观', knowledge: '知识库', sync: '同步', mcp: 'MCP', plugins: '插件', shortcuts: '快捷键' },
+    tabs: { ai: 'AI', appearance: '外观', knowledge: '知识库', sync: '同步', mcp: 'MCP', plugins: '插件', shortcuts: '快捷键', monitoring: '监控', agents: 'Agents' },
     ai: {
       provider: '服务商',
       model: '模型',
@@ -287,6 +287,49 @@ export const zh = {
       configureFor: '配置目标',
       configPath: '配置路径',
     },
+    monitoring: {
+      system: '系统',
+      heapMemory: '堆内存',
+      rss: 'RSS',
+      uptime: '运行时间',
+      nodeVersion: 'Node',
+      application: '应用',
+      requests: '请求数',
+      toolCalls: '工具调用',
+      avgResponse: '平均响应',
+      tokens: 'Token',
+      errors: '错误',
+      knowledgeBase: '知识库',
+      files: '文件数',
+      totalSize: '总大小',
+      rootPath: '根目录',
+      mcpStatus: '状态',
+      mcpRunning: '运行中',
+      mcpStopped: '已停止',
+      mcpPort: '端口',
+      autoRefresh: '每 5 秒自动刷新',
+      fetchError: '加载监控数据失败',
+    },
+    agents: {
+      mcpServer: 'MCP 服务器',
+      running: '运行中',
+      stopped: '未运行',
+      onPort: (port: number) => `端口 :${port}`,
+      refresh: '刷新',
+      refreshing: '刷新中...',
+      connected: '已连接',
+      connectedCount: (n: number) => `已连接 (${n})`,
+      detectedNotConfigured: '已检测未配置',
+      detectedCount: (n: number) => `已检测未配置 (${n})`,
+      notDetected: '未检测到',
+      notDetectedCount: (n: number) => `未检测到 (${n})`,
+      showAll: '显示全部',
+      hideAll: '收起',
+      connect: '连接',
+      noAgents: '本机未检测到任何 Agent。',
+      fetchError: '加载 Agent 数据失败',
+      autoRefresh: '每 30 秒自动刷新',
+    },
     save: '保存',
     saved: '已保存',
     saveFailed: '保存失败',

package/app/lib/metrics.ts

@@ -0,0 +1,81 @@
+/**
+ * In-memory metrics collector for MindOS runtime observability.
+ *
+ * Singleton — import { metrics } from '@/lib/metrics' in any server-side code.
+ * Data resets when the process restarts (no persistence needed).
+ */
+
+export interface MetricsSnapshot {
+  processStartTime: number;
+  agentRequests: number;
+  toolExecutions: number;
+  totalTokens: { input: number; output: number };
+  avgResponseTimeMs: number;
+  errors: number;
+}
+
+const MAX_RESPONSE_TIMES = 100;
+
+class MetricsCollector {
+  private processStartTime = Date.now();
+  private agentRequests = 0;
+  private toolExecutions = 0;
+  private totalTokens = { input: 0, output: 0 };
+  private responseTimes: number[] = [];
+  private errors = 0;
+
+  /** Record a completed agent request with its duration. */
+  recordRequest(durationMs: number): void {
+    this.agentRequests++;
+    this.responseTimes.push(durationMs);
+    if (this.responseTimes.length > MAX_RESPONSE_TIMES) {
+      this.responseTimes.shift();
+    }
+  }
+
+  /** Increment the tool execution counter. */
+  recordToolExecution(): void {
+    this.toolExecutions++;
+  }
+
+  /** Accumulate token usage. */
+  recordTokens(input: number, output: number): void {
+    this.totalTokens.input += input;
+    this.totalTokens.output += output;
+  }
+
+  /** Increment the error counter. */
+  recordError(): void {
+    this.errors++;
+  }
+
+  /** Return a read-only snapshot of all metrics. */
+  getSnapshot(): MetricsSnapshot {
+    const avg =
+      this.responseTimes.length > 0
+        ? Math.round(this.responseTimes.reduce((a, b) => a + b, 0) / this.responseTimes.length)
+        : 0;
+
+    return {
+      processStartTime: this.processStartTime,
+      agentRequests: this.agentRequests,
+      toolExecutions: this.toolExecutions,
+      totalTokens: { ...this.totalTokens },
+      avgResponseTimeMs: avg,
+      errors: this.errors,
+    };
+  }
+
+  /** Reset all counters (useful for testing). */
+  reset(): void {
+    this.processStartTime = Date.now();
+    this.agentRequests = 0;
+    this.toolExecutions = 0;
+    this.totalTokens = { input: 0, output: 0 };
+    this.responseTimes = [];
+    this.errors = 0;
+  }
+}
+
+/** Global singleton — shared across all requests in the same Node process. */
+export const metrics = new MetricsCollector();

package/app/next.config.ts

@@ -3,7 +3,7 @@ import path from "path";
 
 const nextConfig: NextConfig = {
   transpilePackages: ['github-slugger'],
-  serverExternalPackages: ['pdfjs-dist', 'pdf-parse', 'chokidar'],
+  serverExternalPackages: ['pdfjs-dist', 'pdf-parse', 'chokidar', '@mariozechner/pi-ai', '@mariozechner/pi-agent-core'],
   outputFileTracingRoot: path.join(__dirname),
   turbopack: {
     root: path.join(__dirname),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.5.21",
+  "version": "0.5.22",
   "description": "MindOS — Human-Agent Collaborative Mind System. Local-first knowledge base that syncs your mind to all AI Agents via MCP.",
   "keywords": [
     "mindos",