@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/hooks/useMention.ts

@@ -0,0 +1,108 @@
+'use client';
+
+import { useState, useCallback, useEffect } from 'react';
+
+function safeFetchFiles(): Promise<string[]> {
+  return fetch('/api/files')
+    .then((r) => (r.ok ? r.json() : []))
+    .then((data) => (Array.isArray(data) ? data : []))
+    .catch(() => [] as string[]);
+}
+
+export function useMention() {
+  const [allFiles, setAllFiles] = useState<string[]>([]);
+  const [mentionQuery, setMentionQuery] = useState<string | null>(null);
+  const [mentionResults, setMentionResults] = useState<string[]>([]);
+  const [mentionIndex, setMentionIndex] = useState(0);
+
+  const loadFiles = useCallback(() => {
+    safeFetchFiles().then(setAllFiles);
+  }, []);
+
+  useEffect(() => {
+    loadFiles();
+    const handler = () => loadFiles();
+    window.addEventListener('mindos:files-changed', handler);
+    return () => window.removeEventListener('mindos:files-changed', handler);
+  }, [loadFiles]);
+
+  const updateMentionFromInput = useCallback(
+    (val: string, cursorPos?: number) => {
+      const pos = cursorPos ?? val.length;
+      const before = val.slice(0, pos);
+      const atIdx = before.lastIndexOf('@');
+      if (atIdx === -1) {
+        setMentionQuery(null);
+        return;
+      }
+      if (atIdx > 0 && before[atIdx - 1] !== ' ' && before[atIdx - 1] !== '\n') {
+        setMentionQuery(null);
+        return;
+      }
+      const query = before.slice(atIdx + 1);
+      if (query.includes(' ') || query.includes('\n')) {
+        setMentionQuery(null);
+        setMentionResults([]);
+        setMentionIndex(0);
+        return;
+      }
+      const q = query.toLowerCase();
+      if (!q) {
+        setMentionQuery(query);
+        setMentionResults(allFiles.slice(0, 30));
+        setMentionIndex(0);
+        return;
+      }
+      const scored = allFiles
+        .map((f) => {
+          const name = (f.split('/').pop() ?? f).toLowerCase();
+          const fl = f.toLowerCase();
+          let score = 0;
+          if (name.startsWith(q)) score = 100;
+          else if (name.includes(q)) score = 50;
+          else if (fl.includes(q)) score = 10;
+          return { path: f, score };
+        })
+        .filter((x) => x.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, 30);
+      if (scored.length === 0) {
+        setMentionQuery(null);
+        setMentionResults([]);
+        setMentionIndex(0);
+        return;
+      }
+      setMentionQuery(query);
+      setMentionResults(scored.map((x) => x.path));
+      setMentionIndex(0);
+    },
+    [allFiles],
+  );
+
+  const navigateMention = useCallback(
+    (direction: 'up' | 'down') => {
+      if (mentionResults.length === 0) return;
+      if (direction === 'down') {
+        setMentionIndex((i) => Math.min(i + 1, mentionResults.length - 1));
+      } else {
+        setMentionIndex((i) => Math.max(i - 1, 0));
+      }
+    },
+    [mentionResults.length],
+  );
+
+  const resetMention = useCallback(() => {
+    setMentionQuery(null);
+    setMentionResults([]);
+    setMentionIndex(0);
+  }, []);
+
+  return {
+    mentionQuery,
+    mentionResults,
+    mentionIndex,
+    updateMentionFromInput,
+    navigateMention,
+    resetMention,
+  };
+}

package/_standalone/hooks/useResizeDrag.ts

@@ -0,0 +1,84 @@
+'use client';
+
+import { useCallback, useRef } from 'react';
+
+export interface UseResizeDragOptions {
+  /** Current width */
+  width: number;
+  /** Min allowed width */
+  minWidth: number;
+  /** Max allowed width (absolute) */
+  maxWidth: number;
+  /** Max width as ratio of viewport */
+  maxWidthRatio: number;
+  /** 'right' = right-edge drag (mouse right → wider), 'left' = left-edge drag (mouse left → wider) */
+  direction: 'right' | 'left';
+  /** Skip if true (e.g. maximized state) */
+  disabled?: boolean;
+  /** Called on every mousemove with new width */
+  onResize: (width: number) => void;
+  /** Called on mouseup with final width */
+  onResizeEnd: (width: number) => void;
+}
+
+/**
+ * Shared drag-resize logic for panel edges.
+ * Returns a mousedown handler for the resize handle element.
+ */
+export function useResizeDrag({
+  width,
+  minWidth,
+  maxWidth,
+  maxWidthRatio,
+  direction,
+  disabled,
+  onResize,
+  onResizeEnd,
+}: UseResizeDragOptions) {
+  const dragging = useRef(false);
+  const startX = useRef(0);
+  const startWidth = useRef(0);
+  const latestWidthRef = useRef(width);
+  latestWidthRef.current = width;
+
+  // Use refs for callbacks to avoid stale closures in mousemove/mouseup
+  const onResizeRef = useRef(onResize);
+  onResizeRef.current = onResize;
+  const onResizeEndRef = useRef(onResizeEnd);
+  onResizeEndRef.current = onResizeEnd;
+
+  const handleMouseDown = useCallback((e: React.MouseEvent) => {
+    if (disabled) return;
+    e.preventDefault();
+    dragging.current = true;
+    startX.current = e.clientX;
+    startWidth.current = width;
+
+    document.body.classList.add('select-none');
+    document.body.style.cursor = 'col-resize';
+
+    const onMouseMove = (ev: MouseEvent) => {
+      if (!dragging.current) return;
+      const delta = direction === 'right'
+        ? ev.clientX - startX.current
+        : startX.current - ev.clientX;
+      const maxW = Math.min(maxWidth, window.innerWidth * maxWidthRatio);
+      const newWidth = Math.round(Math.max(minWidth, Math.min(maxW, startWidth.current + delta)));
+      onResizeRef.current(newWidth);
+    };
+
+    const onMouseUp = () => {
+      dragging.current = false;
+      document.body.classList.remove('select-none');
+      document.body.style.cursor = '';
+      onResizeEndRef.current(latestWidthRef.current);
+      document.removeEventListener('mousemove', onMouseMove);
+      document.removeEventListener('mouseup', onMouseUp);
+    };
+
+    document.addEventListener('mousemove', onMouseMove);
+    document.addEventListener('mouseup', onMouseUp);
+  }, [width, minWidth, maxWidth, maxWidthRatio, direction, disabled]);
+
+  return handleMouseDown;
+}

package/_standalone/hooks/useSettingsAiAvailable.ts

@@ -0,0 +1,35 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+import { isAiConfiguredForAsk, type SettingsJsonForAi } from '@/lib/settings-ai-client';
+
+export function useSettingsAiAvailable(): { ready: boolean; loading: boolean } {
+  const [ready, setReady] = useState(false);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    let cancelled = false;
+    const doFetch = () => {
+      fetch('/api/settings', { cache: 'no-store' })
+        .then((r) => r.json())
+        .then((d: SettingsJsonForAi) => {
+          if (!cancelled) setReady(isAiConfiguredForAsk(d));
+        })
+        .catch(() => {
+          if (!cancelled) setReady(false);
+        })
+        .finally(() => {
+          if (!cancelled) setLoading(false);
+        });
+    };
+    doFetch();
+    const onChanged = () => doFetch();
+    window.addEventListener('mindos:settings-changed', onChanged);
+    return () => {
+      cancelled = true;
+      window.removeEventListener('mindos:settings-changed', onChanged);
+    };
+  }, []);
+
+  return { ready, loading };
+}

package/_standalone/hooks/useSlashCommand.ts

@@ -0,0 +1,128 @@
+'use client';
+
+import { useState, useCallback, useEffect, useRef } from 'react';
+import type { SkillInfo } from '@/components/settings/types';
+
+export interface SlashItem {
+  type: 'skill';
+  name: string;
+  description: string;
+}
+
+function safeFetchSkills(): Promise<SkillInfo[]> {
+  return fetch('/api/skills')
+    .then((r) => (r.ok ? r.json() : { skills: [] }))
+    .then((data) => (Array.isArray(data?.skills) ? data.skills : []))
+    .catch(() => [] as SkillInfo[]);
+}
+
+export function useSlashCommand() {
+  const [allSkills, setAllSkills] = useState<SkillInfo[]>([]);
+  const [slashQuery, setSlashQuery] = useState<string | null>(null);
+  const [slashResults, setSlashResults] = useState<SlashItem[]>([]);
+  const [slashIndex, setSlashIndex] = useState(0);
+  const loaded = useRef(false);
+
+  const loadSkills = useCallback(async () => {
+    const skills = await safeFetchSkills();
+    setAllSkills(skills.filter((s) => s.enabled));
+    loaded.current = true;
+  }, []);
+
+  useEffect(() => {
+    loadSkills();
+    const handler = () => loadSkills();
+    window.addEventListener('mindos:skills-changed', handler);
+    return () => window.removeEventListener('mindos:skills-changed', handler);
+  }, [loadSkills]);
+
+  const updateSlashFromInput = useCallback(
+    (val: string, cursorPos: number) => {
+      const before = val.slice(0, cursorPos);
+      const slashIdx = before.lastIndexOf('/');
+
+      if (slashIdx === -1) {
+        setSlashQuery(null);
+        return;
+      }
+
+      // `/` must be at line start or preceded by whitespace
+      if (slashIdx > 0 && before[slashIdx - 1] !== ' ' && before[slashIdx - 1] !== '\n') {
+        setSlashQuery(null);
+        return;
+      }
+
+      // No space in the typed query — slash commands are single tokens
+      const query = before.slice(slashIdx + 1);
+      if (query.includes(' ')) {
+        setSlashQuery(null);
+        return;
+      }
+
+      if (!loaded.current) {
+        loadSkills();
+        setSlashQuery(null);
+        return;
+      }
+
+      const q = query.toLowerCase();
+      const items: SlashItem[] = (q
+        ? allSkills
+            .map((s) => {
+              const nl = s.name.toLowerCase();
+              let score = 0;
+              if (nl.startsWith(q)) score = 100;
+              else if (nl.includes(q)) score = 50;
+              else if (s.description.toLowerCase().includes(q)) score = 10;
+              return { s, score };
+            })
+            .filter((x) => x.score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, 20)
+            .map((x) => ({ type: 'skill' as const, name: x.s.name, description: x.s.description }))
+        : allSkills
+            .slice(0, 20)
+            .map((s) => ({ type: 'skill' as const, name: s.name, description: s.description }))
+      );
+
+      if (items.length === 0) {
+        setSlashQuery(null);
+        setSlashResults([]);
+        setSlashIndex(0);
+        return;
+      }
+
+      setSlashQuery(query);
+      setSlashResults(items);
+      setSlashIndex(0);
+    },
+    [allSkills, loadSkills],
+  );
+
+  const navigateSlash = useCallback(
+    (direction: 'up' | 'down') => {
+      if (slashResults.length === 0) return;
+      if (direction === 'down') {
+        setSlashIndex((i) => Math.min(i + 1, slashResults.length - 1));
+      } else {
+        setSlashIndex((i) => Math.max(i - 1, 0));
+      }
+    },
+    [slashResults.length],
+  );
+
+  const resetSlash = useCallback(() => {
+    setSlashQuery(null);
+    setSlashResults([]);
+    setSlashIndex(0);
+  }, []);
+
+  return {
+    slashQuery,
+    slashResults,
+    slashIndex,
+    updateSlashFromInput,
+    navigateSlash,
+    resetSlash,
+  };
+}

package/_standalone/instrumentation.ts

@@ -0,0 +1,60 @@
+export async function register() {
+  if (process.env.NEXT_RUNTIME === 'nodejs') {
+    const { readFileSync } = await import('fs');
+    const { join, resolve } = await import('path');
+    const { homedir } = await import('os');
+    try {
+      const configPath = join(homedir(), '.mindos', 'config.json');
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      if (config.sync?.enabled && config.mindRoot) {
+        // Turbopack statically analyzes ALL forms of require/import — including
+        // createRequire() calls. The only way to load a runtime-computed path
+        // is to hide the require call inside a Function constructor, which is
+        // opaque to bundler static analysis.
+        const projRoot = process.env.MINDOS_PROJECT_ROOT || resolve(process.cwd(), '..');
+        const syncModule = resolve(projRoot, 'bin', 'lib', 'sync.js');
+        // eslint-disable-next-line @typescript-eslint/no-implied-eval
+        const dynamicRequire = new Function('id', 'return require(id)') as (id: string) => any;
+        const { startSyncDaemon } = dynamicRequire(syncModule);
+        await startSyncDaemon(config.mindRoot);
+      }
+    } catch {
+      // Sync not configured or failed to start — silently skip
+    }
+
+    // Cold-start index prewarming: build file tree cache + search index
+    // in the background so the first search doesn't block.
+    process.nextTick(async () => {
+      try {
+        const { getFileTree, startFileWatcher } = await import('@/lib/fs');
+        getFileTree();       // Builds file tree cache + starts file watcher
+        startFileWatcher();  // Ensure watcher is running
+      } catch {
+        // mindRoot not configured yet — skip prewarming
+      }
+    });
+
+    // Skill auto-update: check if bundled skills are newer than installed
+    // ones (covers both CLI startup and Desktop hot-update restarts).
+    process.nextTick(async () => {
+      try {
+        const projRoot = process.env.MINDOS_PROJECT_ROOT || resolve(process.cwd(), '..');
+        const skillCheckModule = resolve(projRoot, 'bin', 'lib', 'skill-check.js');
+        // eslint-disable-next-line @typescript-eslint/no-implied-eval
+        const dynamicRequireSkill = new Function('id', 'return require(id)') as (id: string) => any;
+        const { checkSkillVersions, updateSkill } = dynamicRequireSkill(skillCheckModule);
+        const mismatches = checkSkillVersions(projRoot);
+        for (const m of mismatches) {
+          try {
+            updateSkill(m.bundledPath, m.installPath);
+            console.log(`[SkillSync] Updated ${m.name}${m.agent ? ` (${m.agent})` : ''}: v${m.installed} → v${m.bundled}`);
+          } catch (err) {
+            console.warn(`[SkillSync] Failed to update ${m.name}: ${err instanceof Error ? err.message : err}`);
+          }
+        }
+      } catch {
+        // skill-check not available or failed — silently skip
+      }
+    });
+  }
+}

package/_standalone/lib/a2a/index.ts

@@ -0,0 +1,31 @@
+export { buildAgentCard } from './agent-card';
+export { handleSendMessage, handleGetTask, handleCancelTask } from './task-handler';
+export { discoverAgent, discoverAgents, delegateTask, checkRemoteTaskStatus, getDiscoveredAgents, getAgent, clearRegistry } from './client';
+export { matchSkill, decompose, createPlan, executePlan } from './orchestrator';
+export { a2aTools } from './a2a-tools';
+export { A2A_ERRORS } from './types';
+export type {
+  AgentCard,
+  AgentInterface,
+  AgentCapabilities,
+  AgentSkill,
+  SecurityScheme,
+  JsonRpcRequest,
+  JsonRpcResponse,
+  JsonRpcError,
+  TaskState,
+  MessageRole,
+  MessagePart,
+  A2AMessage,
+  TaskStatus,
+  TaskArtifact,
+  A2ATask,
+  SendMessageParams,
+  GetTaskParams,
+  CancelTaskParams,
+  RemoteAgent,
+  SubTask,
+  ExecutionStrategy,
+  OrchestrationPlan,
+  SkillMatch,
+} from './types';

package/_standalone/lib/acp/bridge.ts

@@ -0,0 +1,144 @@
+/**
+ * A2A-ACP Bridge — Translate between A2A protocol and ACP protocol.
+ * Allows A2A agents to delegate to ACP agents transparently,
+ * and ACP session results to be returned as A2A tasks.
+ */
+
+import type { A2AMessage, A2ATask, TaskState } from '@/lib/a2a/types';
+import type { AcpPromptResponse, AcpSessionUpdate } from './types';
+import { createSession, prompt, closeSession } from './session';
+
+/* ── A2A → ACP ─────────────────────────────────────────────────────────── */
+
+/**
+ * Bridge an A2A SendMessage request to an ACP session/prompt.
+ * Creates a session, sends the message, returns the result, then closes.
+ */
+export async function bridgeA2aToAcp(
+  a2aMessage: A2AMessage,
+  acpAgentId: string,
+): Promise<A2ATask> {
+  const taskId = `acp-bridge-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+  // Extract text from A2A message parts
+  const text = a2aMessage.parts
+    .map(p => p.text ?? '')
+    .filter(Boolean)
+    .join('\n');
+
+  if (!text) {
+    return makeFailedTask(taskId, 'No text content in A2A message');
+  }
+
+  let session;
+  try {
+    session = await createSession(acpAgentId);
+  } catch (err) {
+    return makeFailedTask(taskId, `Failed to create ACP session: ${(err as Error).message}`);
+  }
+
+  try {
+    const response = await prompt(session.id, text);
+    return bridgeAcpResponseToA2a(taskId, response);
+  } catch (err) {
+    return makeFailedTask(taskId, `ACP prompt failed: ${(err as Error).message}`);
+  } finally {
+    await closeSession(session.id).catch(() => {});
+  }
+}
+
+/* ── ACP → A2A ─────────────────────────────────────────────────────────── */
+
+/**
+ * Convert a completed ACP prompt response to an A2A task result.
+ */
+export function bridgeAcpResponseToA2a(
+  taskId: string,
+  response: AcpPromptResponse,
+): A2ATask {
+  return {
+    id: taskId,
+    status: {
+      state: 'TASK_STATE_COMPLETED',
+      message: {
+        role: 'ROLE_AGENT',
+        parts: [{ text: response.text }],
+      },
+      timestamp: new Date().toISOString(),
+    },
+    artifacts: response.text ? [{
+      artifactId: `${taskId}-artifact`,
+      parts: [{ text: response.text }],
+    }] : undefined,
+  };
+}
+
+/**
+ * Convert a stream of ACP session updates to A2A task updates.
+ * Aggregates text updates and maps final state.
+ */
+export function bridgeAcpUpdatesToA2a(
+  taskId: string,
+  updates: AcpSessionUpdate[],
+): A2ATask {
+  let aggregatedText = '';
+  let finalState: TaskState = 'TASK_STATE_WORKING';
+  let errorMessage = '';
+
+  for (const update of updates) {
+    switch (update.type) {
+      case 'text':
+      case 'agent_message_chunk':
+        aggregatedText += update.text ?? '';
+        break;
+      case 'agent_thought_chunk':
+        // Include thought in output with label
+        if (update.text) aggregatedText += update.text;
+        break;
+      case 'done':
+        finalState = 'TASK_STATE_COMPLETED';
+        break;
+      case 'error':
+        finalState = 'TASK_STATE_FAILED';
+        errorMessage = update.error ?? 'Unknown error';
+        break;
+      // tool_call, tool_call_update, plan, etc. — pass through for now
+    }
+  }
+
+  if (finalState === 'TASK_STATE_FAILED') {
+    return makeFailedTask(taskId, errorMessage);
+  }
+
+  return {
+    id: taskId,
+    status: {
+      state: finalState,
+      message: aggregatedText ? {
+        role: 'ROLE_AGENT',
+        parts: [{ text: aggregatedText }],
+      } : undefined,
+      timestamp: new Date().toISOString(),
+    },
+    artifacts: aggregatedText ? [{
+      artifactId: `${taskId}-artifact`,
+      parts: [{ text: aggregatedText }],
+    }] : undefined,
+  };
+}
+
+/* ── Internal ──────────────────────────────────────────────────────────── */
+
+function makeFailedTask(taskId: string, error: string): A2ATask {
+  return {
+    id: taskId,
+    status: {
+      state: 'TASK_STATE_FAILED',
+      message: {
+        role: 'ROLE_AGENT',
+        parts: [{ text: error }],
+      },
+      timestamp: new Date().toISOString(),
+    },
+  };
+}

package/_standalone/lib/acp/index.ts

@@ -0,0 +1,38 @@
+export { fetchAcpRegistry, getAcpAgents, findAcpAgent, clearRegistryCache } from './registry';
+export { spawnAndConnect, spawnAcpAgent, killAgent, killAllAgents, getProcess, getActiveProcesses } from './subprocess';
+export { createSession, createSessionFromEntry, loadSession, listSessions, prompt, promptStream, cancelPrompt, setMode, setConfigOption, closeSession, getSession, getActiveSessions, closeAllSessions } from './session';
+export { bridgeA2aToAcp, bridgeAcpResponseToA2a, bridgeAcpUpdatesToA2a } from './bridge';
+export { acpTools } from './acp-tools';
+export { AGENT_DESCRIPTORS, AGENT_ALIASES, resolveAlias, findUserOverride, getDetectableAgents } from './agent-descriptors';
+export { ACP_ERRORS } from './types';
+export type {
+  AcpAgentCapabilities,
+  AcpClientCapabilities,
+  AcpContentBlock,
+  AcpStopReason,
+  AcpMode,
+  AcpConfigOption,
+  AcpConfigOptionEntry,
+  AcpAuthMethod,
+  AcpSessionState,
+  AcpSession,
+  AcpSessionInfo,
+  AcpPromptResponse,
+  AcpUpdateType,
+  AcpSessionUpdate,
+  AcpToolCall,
+  AcpToolCallFull,
+  AcpToolCallKind,
+  AcpToolCallStatus,
+  AcpToolResult,
+  AcpPlan,
+  AcpPlanEntry,
+  AcpPlanEntryStatus,
+  AcpPlanEntryPriority,
+  AcpPermissionOutcome,
+  AcpRegistryEntry,
+  AcpRegistry,
+  AcpTransportType,
+} from './types';
+export type { AcpProcess, AcpClientCallbacks, AcpConnection } from './subprocess';
+export type { AcpAgentDescriptor, AcpAgentOverride, ResolvedAgentCommand, DetectableAgent } from './agent-descriptors';