@geminilight/mindos 0.5.21 → 0.5.22

package/app/app/api/ask/route.ts

@@ -13,7 +13,10 @@ import {
   createTransformContext,
 } from '@/lib/agent/context';
 import { logAgentOp } from '@/lib/agent/log';
+import { loadSkillRules } from '@/lib/agent/skill-rules';
 import { readSettings } from '@/lib/settings';
+import { MindOSError, apiError, ErrorCodes } from '@/lib/errors';
+import { metrics } from '@/lib/metrics';
 import { assertNotProtected } from '@/lib/core';
 import type { Message as FrontendMessage } from '@/lib/types';
 
@@ -160,7 +163,7 @@ export async function POST(req: NextRequest) {
   try {
     body = await req.json();
   } catch {
-    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
+    return apiError(ErrorCodes.INVALID_REQUEST, 'Invalid JSON body', 400);
   }
 
   const { messages, currentFile, attachedFiles, uploadedFiles } = body;
@@ -176,12 +179,18 @@ export async function POST(req: NextRequest) {
   const contextStrategy = agentConfig.contextStrategy ?? 'auto';
 
   // Auto-load skill + bootstrap context for each request.
-  // TODO (optimization): Consider caching bootstrap files with TTL to reduce per-request IO overhead.
-  // Current behavior: 8 synchronous file reads per request. For users with large knowledge bases,
-  // this adds ~10-50ms latency. Mitigation: Cache with 5min TTL or lazy-load on-demand.
-  const skillPath = path.resolve(process.cwd(), 'data/skills/mindos/SKILL.md');
+  // 1. SKILL.md — static trigger + protocol (always loaded)
+  // 2. skill-rules.md — user's knowledge base operating rules (if exists)
+  // 3. user-rules.md — user's personalized rules (if exists)
+  const isZh = serverSettings.disabledSkills?.includes('mindos') ?? false;
+  const skillDirName = isZh ? 'mindos-zh' : 'mindos';
+  const skillPath = path.resolve(process.cwd(), `data/skills/${skillDirName}/SKILL.md`);
   const skill = readAbsoluteFile(skillPath);
 
+  // Progressive skill loading: read skill-rules + user-rules from knowledge base
+  const mindRoot = getMindRoot();
+  const { skillRules, userRules } = loadSkillRules(mindRoot, skillDirName);
+
   const targetDir = dirnameOf(currentFile);
   const bootstrap = {
     instruction: readKnowledgeFile('INSTRUCTION.md'),
@@ -199,6 +208,8 @@ export async function POST(req: NextRequest) {
   const truncationWarnings: string[] = [];
   if (!skill.ok) initFailures.push(`skill.mindos: failed (${skill.error})`);
   if (skill.ok && skill.truncated) truncationWarnings.push('skill.mindos was truncated');
+  if (skillRules.ok && skillRules.truncated) truncationWarnings.push('skill-rules.md was truncated');
+  if (userRules.ok && userRules.truncated) truncationWarnings.push('user-rules.md was truncated');
   if (!bootstrap.instruction.ok) initFailures.push(`bootstrap.instruction: failed (${bootstrap.instruction.error})`);
   if (bootstrap.instruction.ok && bootstrap.instruction.truncated) truncationWarnings.push('bootstrap.instruction was truncated');
   if (!bootstrap.index.ok) initFailures.push(`bootstrap.index: failed (${bootstrap.index.error})`);
@@ -222,6 +233,13 @@ export async function POST(req: NextRequest) {
 
   const initContextBlocks: string[] = [];
   if (skill.ok) initContextBlocks.push(`## mindos_skill_md\n\n${skill.content}`);
+  // Progressive skill loading: inject skill-rules and user-rules after SKILL.md
+  if (skillRules.ok && !skillRules.empty) {
+    initContextBlocks.push(`## skill_rules\n\nOperating rules loaded from knowledge base (.agents/skills/${skillDirName}/skill-rules.md):\n\n${skillRules.content}`);
+  }
+  if (userRules.ok && !userRules.empty) {
+    initContextBlocks.push(`## user_rules\n\nUser personalization rules (.agents/skills/${skillDirName}/user-rules.md):\n\n${userRules.content}`);
+  }
   if (bootstrap.instruction.ok) initContextBlocks.push(`## bootstrap_instruction\n\n${bootstrap.instruction.content}`);
   if (bootstrap.index.ok) initContextBlocks.push(`## bootstrap_index\n\n${bootstrap.index.content}`);
   if (bootstrap.config_json.ok) initContextBlocks.push(`## bootstrap_config_json\n\n${bootstrap.config_json.content}`);
@@ -381,6 +399,7 @@ export async function POST(req: NextRequest) {
 
     // ── SSE Stream ──
     const encoder = new TextEncoder();
+    const requestStartTime = Date.now();
     const stream = new ReadableStream({
       start(controller) {
         function send(event: MindOSSSEvent) {
@@ -404,6 +423,7 @@ export async function POST(req: NextRequest) {
             });
           } else if (isToolExecutionEndEvent(event)) {
             const { toolCallId, output, isError } = getToolExecutionEnd(event);
+            metrics.recordToolExecution();
             send({
               type: 'tool_end',
               toolCallId,
@@ -413,6 +433,12 @@ export async function POST(req: NextRequest) {
           } else if (isTurnEndEvent(event)) {
             stepCount++;
 
+            // Record token usage if available from the turn
+            const turnUsage = (event as any).usage;
+            if (turnUsage && typeof turnUsage.inputTokens === 'number') {
+              metrics.recordTokens(turnUsage.inputTokens, turnUsage.outputTokens ?? 0);
+            }
+
             // Track tool calls for loop detection (lock-free batch update).
             // Deterministic JSON.stringify ensures consistent input comparison.
             const { toolResults } = getTurnEndData(event);
@@ -452,9 +478,12 @@ export async function POST(req: NextRequest) {
         });
 
         agent.prompt(lastUserContent).then(() => {
+          metrics.recordRequest(Date.now() - requestStartTime);
           send({ type: 'done' });
           controller.close();
         }).catch((err) => {
+          metrics.recordRequest(Date.now() - requestStartTime);
+          metrics.recordError();
           send({ type: 'error', message: err instanceof Error ? err.message : String(err) });
           controller.close();
         });
@@ -471,9 +500,9 @@ export async function POST(req: NextRequest) {
     });
   } catch (err) {
     console.error('[ask] Failed to initialize model:', err);
-    return NextResponse.json(
-      { error: err instanceof Error ? err.message : 'Failed to initialize AI model' },
-      { status: 500 },
-    );
+    if (err instanceof MindOSError) {
+      return apiError(err.code, err.message);
+    }
+    return apiError(ErrorCodes.MODEL_INIT_FAILED, err instanceof Error ? err.message : 'Failed to initialize AI model', 500);
   }
 }

package/app/app/api/monitoring/route.ts

@@ -0,0 +1,95 @@
+export const dynamic = 'force-dynamic';
+import { NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+import { getMindRoot } from '@/lib/fs';
+import { metrics } from '@/lib/metrics';
+
+// Aligned with IGNORED_DIRS in lib/fs.ts and lib/core/tree.ts
+const IGNORED_DIRS = new Set(['.git', 'node_modules', 'app', '.next', '.DS_Store', 'mcp']);
+
+/**
+ * Recursively count files and sum their sizes under a directory.
+ * Skips directories in IGNORED_DIRS (aligned with the rest of the codebase).
+ */
+function walkStats(dir: string): { fileCount: number; totalSizeBytes: number } {
+  let fileCount = 0;
+  let totalSizeBytes = 0;
+
+  function walk(current: string) {
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (IGNORED_DIRS.has(entry.name)) continue;
+      const fullPath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        try {
+          const stat = fs.statSync(fullPath);
+          fileCount++;
+          totalSizeBytes += stat.size;
+        } catch { /* skip unreadable files */ }
+      }
+    }
+  }
+
+  walk(dir);
+  return { fileCount, totalSizeBytes };
+}
+
+// ── TTL cache for walkStats (avoid blocking event loop every 5s poll) ──
+let cachedKbStats: { fileCount: number; totalSizeBytes: number } | null = null;
+let cachedKbStatsTs = 0;
+const KB_STATS_TTL = 30_000; // 30s
+
+function getCachedKbStats(mindRoot: string): { fileCount: number; totalSizeBytes: number } {
+  const now = Date.now();
+  if (cachedKbStats && now - cachedKbStatsTs < KB_STATS_TTL) return cachedKbStats;
+  cachedKbStats = walkStats(mindRoot);
+  cachedKbStatsTs = now;
+  return cachedKbStats;
+}
+
+export async function GET() {
+  const snap = metrics.getSnapshot();
+  const mem = process.memoryUsage();
+  const mindRoot = getMindRoot();
+
+  const kbStats = getCachedKbStats(mindRoot);
+
+  // Detect MCP status from environment / config
+  const mcpPort = Number(process.env.MCP_PORT) || 3457;
+
+  return NextResponse.json({
+    system: {
+      uptimeMs: Date.now() - snap.processStartTime,
+      memory: {
+        heapUsed: mem.heapUsed,
+        heapTotal: mem.heapTotal,
+        rss: mem.rss,
+      },
+      nodeVersion: process.version,
+    },
+    application: {
+      agentRequests: snap.agentRequests,
+      toolExecutions: snap.toolExecutions,
+      totalTokens: snap.totalTokens,
+      avgResponseTimeMs: snap.avgResponseTimeMs,
+      errors: snap.errors,
+    },
+    knowledgeBase: {
+      root: mindRoot,
+      fileCount: kbStats.fileCount,
+      totalSizeBytes: kbStats.totalSizeBytes,
+    },
+    mcp: {
+      running: true, // If this endpoint responds, the server is running
+      port: mcpPort,
+    },
+  });
+}

package/app/components/SettingsModal.tsx

@@ -1,7 +1,7 @@
 'use client';
 
 import { useEffect, useState, useCallback, useRef } from 'react';
-import { X, Settings, Loader2, AlertCircle, CheckCircle2, RotateCcw, Sparkles, Palette, Database, RefreshCw, Plug, Puzzle } from 'lucide-react';
+import { X, Settings, Loader2, AlertCircle, CheckCircle2, RotateCcw, Sparkles, Palette, Database, RefreshCw, Plug, Puzzle, Activity, Users } from 'lucide-react';
 import { useLocale } from '@/lib/LocaleContext';
 import { getAllRenderers, loadDisabledState, isRendererEnabled } from '@/lib/renderers/registry';
 import { apiFetch } from '@/lib/api';
@@ -14,6 +14,8 @@ import { KnowledgeTab } from './settings/KnowledgeTab';
 import { PluginsTab } from './settings/PluginsTab';
 import { SyncTab } from './settings/SyncTab';
 import { McpTab } from './settings/McpTab';
+import { MonitoringTab } from './settings/MonitoringTab';
+import { AgentsTab } from './settings/AgentsTab';
 
 interface SettingsModalProps {
   open: boolean;
@@ -147,6 +149,8 @@ export default function SettingsModal({ open, onClose, initialTab }: SettingsMod
     { id: 'sync', label: t.settings.tabs.sync ?? 'Sync', icon: <RefreshCw size={13} /> },
     { id: 'mcp', label: t.settings.tabs.mcp ?? 'MCP', icon: <Plug size={13} /> },
     { id: 'plugins', label: t.settings.tabs.plugins, icon: <Puzzle size={13} /> },
+    { id: 'monitoring', label: t.settings.tabs.monitoring, icon: <Activity size={13} /> },
+    { id: 'agents', label: t.settings.tabs.agents ?? 'Agents', icon: <Users size={13} /> },
   ];
 
   return (
@@ -197,7 +201,7 @@ export default function SettingsModal({ open, onClose, initialTab }: SettingsMod
               <p className="text-sm text-destructive font-medium">Failed to load settings</p>
               <p className="text-xs text-muted-foreground">Check that the server is running and AUTH_TOKEN is configured correctly.</p>
             </div>
-          ) : !data && tab !== 'appearance' && tab !== 'mcp' && tab !== 'sync' ? (
+          ) : !data && tab !== 'appearance' && tab !== 'mcp' && tab !== 'sync' && tab !== 'agents' ? (
             <div className="flex justify-center py-8">
               <Loader2 size={18} className="animate-spin text-muted-foreground" />
             </div>
@@ -209,6 +213,8 @@ export default function SettingsModal({ open, onClose, initialTab }: SettingsMod
               {tab === 'plugins' && <PluginsTab pluginStates={pluginStates} setPluginStates={setPluginStates} t={t} />}
               {tab === 'sync' && <SyncTab t={t} />}
               {tab === 'mcp' && <McpTab t={t} />}
+              {tab === 'monitoring' && <MonitoringTab t={t} />}
+              {tab === 'agents' && <AgentsTab t={t} />}
             </>
           )}
         </div>

package/app/components/settings/AgentsTab.tsx

@@ -0,0 +1,240 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { Loader2, RefreshCw, ChevronDown, ChevronRight, ExternalLink } from 'lucide-react';
+import { apiFetch } from '@/lib/api';
+import type { McpStatus, AgentInfo } from './types';
+import type { Messages } from '@/lib/i18n';
+
+interface AgentsTabProps {
+  t: Messages;
+}
+
+export function AgentsTab({ t }: AgentsTabProps) {
+  const [agents, setAgents] = useState<AgentInfo[]>([]);
+  const [mcpStatus, setMcpStatus] = useState<McpStatus | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(false);
+  const [refreshing, setRefreshing] = useState(false);
+  const [showNotDetected, setShowNotDetected] = useState(false);
+  const intervalRef = useRef<ReturnType<typeof setInterval>>(undefined);
+
+  const a = t.settings?.agents as Record<string, unknown> | undefined;
+
+  // i18n helpers with fallbacks
+  const txt = (key: string, fallback: string) => (a?.[key] as string) ?? fallback;
+  const txtFn = <T,>(key: string, fallback: (v: T) => string) =>
+    (a?.[key] as ((v: T) => string) | undefined) ?? fallback;
+
+  const fetchAll = useCallback(async (silent = false) => {
+    if (!silent) setError(false);
+    try {
+      const [statusData, agentsData] = await Promise.all([
+        apiFetch<McpStatus>('/api/mcp/status'),
+        apiFetch<{ agents: AgentInfo[] }>('/api/mcp/agents'),
+      ]);
+      setMcpStatus(statusData);
+      setAgents(agentsData.agents);
+      setError(false);
+    } catch {
+      if (!silent) setError(true);
+    }
+    setLoading(false);
+    setRefreshing(false);
+  }, []);
+
+  // Initial fetch + 30s auto-refresh
+  useEffect(() => {
+    fetchAll();
+    intervalRef.current = setInterval(() => fetchAll(true), 30_000);
+    return () => clearInterval(intervalRef.current);
+  }, [fetchAll]);
+
+  const handleRefresh = () => {
+    setRefreshing(true);
+    fetchAll();
+  };
+
+  if (loading) {
+    return (
+      <div className="flex justify-center py-8">
+        <Loader2 size={18} className="animate-spin text-muted-foreground" />
+      </div>
+    );
+  }
+
+  if (error && agents.length === 0) {
+    return (
+      <div className="flex flex-col items-center gap-3 py-8 text-center">
+        <p className="text-sm text-destructive">{txt('fetchError', 'Failed to load agent data')}</p>
+        <button
+          onClick={handleRefresh}
+          className="flex items-center gap-1.5 px-3 py-1.5 text-xs rounded-lg border border-border text-muted-foreground hover:text-foreground hover:bg-muted transition-colors"
+        >
+          <RefreshCw size={12} />
+          {txt('refresh', 'Refresh')}
+        </button>
+      </div>
+    );
+  }
+
+  // Group agents
+  const connected = agents.filter(a => a.present && a.installed);
+  const detected = agents.filter(a => a.present && !a.installed);
+  const notFound = agents.filter(a => !a.present);
+
+  return (
+    <div className="space-y-5">
+      {/* MCP Server Status */}
+      <div className="rounded-xl border border-border bg-card p-4 flex items-center justify-between">
+        <div className="flex items-center gap-3">
+          <span className="text-sm font-medium text-foreground">{txt('mcpServer', 'MCP Server')}</span>
+          {mcpStatus?.running ? (
+            <span className="flex items-center gap-1.5 text-xs">
+              <span className="w-2 h-2 rounded-full bg-emerald-500 inline-block" />
+              <span className="text-emerald-600 dark:text-emerald-400">
+                {txt('running', 'Running')} {txtFn<number>('onPort', (p) => `on :${p}`)(mcpStatus.port)}
+              </span>
+            </span>
+          ) : (
+            <span className="flex items-center gap-1.5 text-xs">
+              <span className="w-2 h-2 rounded-full bg-zinc-400 inline-block" />
+              <span className="text-muted-foreground">{txt('stopped', 'Not running')}</span>
+            </span>
+          )}
+        </div>
+        <button
+          onClick={handleRefresh}
+          disabled={refreshing}
+          className="flex items-center gap-1.5 px-2.5 py-1 text-xs rounded-lg border border-border text-muted-foreground hover:text-foreground hover:bg-muted disabled:opacity-50 transition-colors"
+        >
+          <RefreshCw size={12} className={refreshing ? 'animate-spin' : ''} />
+          {refreshing ? txt('refreshing', 'Refreshing...') : txt('refresh', 'Refresh')}
+        </button>
+      </div>
+
+      {/* Connected Agents */}
+      {connected.length > 0 && (
+        <section>
+          <h3 className="text-xs font-medium text-muted-foreground uppercase tracking-wider mb-3">
+            {txtFn<number>('connectedCount', (n) => `Connected (${n})`)(connected.length)}
+          </h3>
+          <div className="space-y-2">
+            {connected.map(agent => (
+              <AgentCard key={agent.key} agent={agent} status="connected" />
+            ))}
+          </div>
+        </section>
+      )}
+
+      {/* Detected but not configured */}
+      {detected.length > 0 && (
+        <section>
+          <h3 className="text-xs font-medium text-muted-foreground uppercase tracking-wider mb-3">
+            {txtFn<number>('detectedCount', (n) => `Detected but not configured (${n})`)(detected.length)}
+          </h3>
+          <div className="space-y-2">
+            {detected.map(agent => (
+              <AgentCard
+                key={agent.key}
+                agent={agent}
+                status="detected"
+                connectLabel={txt('connect', 'Connect')}
+              />
+            ))}
+          </div>
+        </section>
+      )}
+
+      {/* Not Detected */}
+      {notFound.length > 0 && (
+        <section>
+          <button
+            onClick={() => setShowNotDetected(!showNotDetected)}
+            className="flex items-center gap-1.5 text-xs font-medium text-muted-foreground uppercase tracking-wider mb-3 hover:text-foreground transition-colors"
+          >
+            {showNotDetected ? <ChevronDown size={14} /> : <ChevronRight size={14} />}
+            {txtFn<number>('notDetectedCount', (n) => `Not Detected (${n})`)(notFound.length)}
+          </button>
+          {showNotDetected && (
+            <div className="space-y-2">
+              {notFound.map(agent => (
+                <AgentCard key={agent.key} agent={agent} status="notFound" />
+              ))}
+            </div>
+          )}
+        </section>
+      )}
+
+      {/* Empty state */}
+      {agents.length === 0 && (
+        <p className="text-sm text-muted-foreground text-center py-4">
+          {txt('noAgents', 'No agents detected on this machine.')}
+        </p>
+      )}
+
+      {/* Auto-refresh hint */}
+      <p className="text-[10px] text-muted-foreground/60 text-center">
+        {txt('autoRefresh', 'Auto-refresh every 30s')}
+      </p>
+    </div>
+  );
+}
+
+/* ── Agent Card ──────────────────────────────────────────────── */
+
+function AgentCard({
+  agent,
+  status,
+  connectLabel,
+}: {
+  agent: AgentInfo;
+  status: 'connected' | 'detected' | 'notFound';
+  connectLabel?: string;
+}) {
+  const dot =
+    status === 'connected' ? 'bg-emerald-500' :
+    status === 'detected' ? 'bg-amber-500' :
+    'bg-zinc-400';
+
+  return (
+    <div className="rounded-lg border border-border bg-card/50 px-4 py-3 flex items-center justify-between gap-3">
+      <div className="flex items-center gap-3 min-w-0">
+        <span className={`w-2 h-2 rounded-full shrink-0 ${dot}`} />
+        <span className="text-sm font-medium text-foreground truncate">{agent.name}</span>
+        {status === 'connected' && (
+          <div className="flex items-center gap-2 text-[11px] text-muted-foreground">
+            <span className="px-1.5 py-0.5 rounded bg-muted">{agent.transport}</span>
+            <span className="px-1.5 py-0.5 rounded bg-muted">{agent.scope}</span>
+            {agent.configPath && (
+              <span className="truncate max-w-[200px]" title={agent.configPath}>
+                {agent.configPath.replace(/^.*[/\\]/, '')}
+              </span>
+            )}
+          </div>
+        )}
+      </div>
+      {status === 'detected' && (
+        <a
+          href="#"
+          onClick={(e) => {
+            e.preventDefault();
+            // Navigate to MCP tab by dispatching a custom event
+            const settingsModal = document.querySelector('[role="dialog"][aria-label="Settings"]');
+            if (settingsModal) {
+              const mcpBtn = settingsModal.querySelectorAll('button');
+              for (const btn of mcpBtn) {
+                if (btn.textContent?.trim() === 'MCP') {
+                  btn.click();
+                  break;
+                }
+              }
+            }
+          }}
+          className="flex items-center gap-1 px-2.5 py-1 text-xs rounded-lg bg-amber-500/10 text-amber-600 dark:text-amber-400 hover:bg-amber-500/20 transition-colors shrink-0"
+        >
+          {connectLabel ?? 'Connect'}
+          <ExternalLink size={11} />
+        </a>
+      )}
+    </div>
+  );
+}