@geminilight/mindos 0.5.69 → 0.6.0

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

@@ -1,17 +1,24 @@
 export const dynamic = 'force-dynamic';
-import { Agent, type AgentEvent, type BeforeToolCallContext, type BeforeToolCallResult, type AfterToolCallContext, type AfterToolCallResult } from '@mariozechner/pi-agent-core';
+import type { AgentTool, AgentToolResult } from '@mariozechner/pi-agent-core';
+import {
+  type AgentSessionEvent as AgentEvent,
+  AuthStorage,
+  convertToLlm,
+  createAgentSession,
+  DefaultResourceLoader,
+  ModelRegistry,
+  type ToolDefinition,
+  SessionManager,
+  SettingsManager,
+} from '@mariozechner/pi-coding-agent';
 import { NextRequest, NextResponse } from 'next/server';
 import fs from 'fs';
 import path from 'path';
 import { getFileContent, getMindRoot } from '@/lib/fs';
 import { getModelConfig } from '@/lib/agent/model';
-import { knowledgeBaseTools, WRITE_TOOLS, truncate } from '@/lib/agent/tools';
+import { getRequestScopedTools, WRITE_TOOLS, truncate } from '@/lib/agent/tools';
 import { AGENT_SYSTEM_PROMPT } from '@/lib/agent/prompt';
 import { toAgentMessages } from '@/lib/agent/to-agent-messages';
-import {
-  estimateTokens, estimateStringTokens, getContextLimit,
-  createTransformContext,
-} from '@/lib/agent/context';
 import { logAgentOp } from '@/lib/agent/log';
 import { readSettings } from '@/lib/settings';
 import { MindOSError, apiError, ErrorCodes } from '@/lib/errors';
@@ -147,6 +154,64 @@ function dirnameOf(filePath?: string): string | null {
   return normalized.slice(0, idx);
 }
 
+function textToolResult(text: string): AgentToolResult<Record<string, never>> {
+  return { content: [{ type: 'text', text }], details: {} };
+}
+
+function getProtectedPaths(toolName: string, args: Record<string, unknown>): string[] {
+  const pathsToCheck: string[] = [];
+  if (toolName === 'batch_create_files' && Array.isArray((args as any).files)) {
+    (args as any).files.forEach((f: any) => { if (f.path) pathsToCheck.push(f.path); });
+  } else {
+    const singlePath = (args as any).path ?? (args as any).from_path;
+    if (typeof singlePath === 'string') pathsToCheck.push(singlePath);
+  }
+  return pathsToCheck;
+}
+
+function toPiCustomToolDefinitions(tools: AgentTool<any>[]): ToolDefinition[] {
+  return tools.map((tool) => ({
+    name: tool.name,
+    label: tool.label,
+    description: tool.description,
+    parameters: tool.parameters as any,
+    execute: async (toolCallId, params, signal, onUpdate) => {
+      const args = (params ?? {}) as Record<string, unknown>;
+
+      if (WRITE_TOOLS.has(tool.name)) {
+        for (const filePath of getProtectedPaths(tool.name, args)) {
+          try {
+            assertNotProtected(filePath, 'modified by AI agent');
+          } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            return textToolResult(`Write-protection error: ${errorMsg}. You CANNOT modify ${filePath} because it is system-protected. Please tell the user you don't have permission to do this.`);
+          }
+        }
+      }
+
+      const result = await tool.execute(toolCallId, params, signal, onUpdate as any);
+      const outputText = result?.content
+        ?.filter((p: any) => p.type === 'text')
+        .map((p: any) => p.text)
+        .join('') ?? '';
+
+      try {
+        logAgentOp({
+          ts: new Date().toISOString(),
+          tool: tool.name,
+          params: args,
+          result: outputText.startsWith('Error:') ? 'error' : 'ok',
+          message: outputText.slice(0, 200),
+        });
+      } catch {
+        // logging must never kill the stream
+      }
+
+      return result;
+    },
+  }));
+}
+
 // ---------------------------------------------------------------------------
 // POST /api/ask
 // ---------------------------------------------------------------------------
@@ -328,91 +393,60 @@ export async function POST(req: NextRequest) {
     const historyMessages = agentMessages.slice(0, -1);
 
     // Capture API key for this request — safe since each POST creates a new Agent instance.
-    // Even though JS closures are lexically scoped, being explicit guards against future refactors.
     const requestApiKey = apiKey;
+    const projectRoot = process.env.MINDOS_PROJECT_ROOT || path.resolve(process.cwd(), '..');
+    const requestTools = await getRequestScopedTools();
+    const customTools = toPiCustomToolDefinitions(requestTools);
+
+    const authStorage = AuthStorage.create();
+    authStorage.setRuntimeApiKey(provider, requestApiKey);
+    const modelRegistry = new ModelRegistry(authStorage);
+    const settingsManager = SettingsManager.inMemory({
+      enableSkillCommands: true,
+      ...(enableThinking && provider === 'anthropic' ? { thinkingBudgets: { medium: thinkingBudget } } : {}),
+      ...(contextStrategy === 'off' ? { compaction: { enabled: false } } : {}),
+    });
 
-    // ── Loop detection state ──
-    const stepHistory: Array<{ tool: string; input: string }> = [];
-    let stepCount = 0;
-    let loopCooldown = 0;
-
-    // ── Create Agent (per-request lifecycle) ──
-    const agent = new Agent({
-      initialState: {
-        systemPrompt,
-        model,
-        thinkingLevel: (enableThinking && provider === 'anthropic') ? 'medium' : 'off',
-        tools: knowledgeBaseTools,
-        messages: historyMessages,
-      },
-      getApiKey: async () => requestApiKey,
-      toolExecution: 'parallel',
-
-      // Context management: truncate → compact → prune
-      transformContext: createTransformContext(
-        systemPrompt,
-        modelName,
-        () => model,
-        apiKey,
-        contextStrategy,
-      ),
-
-      // Write-protection: block writes to protected files gracefully
-      beforeToolCall: async (context: BeforeToolCallContext): Promise<BeforeToolCallResult | undefined> => {
-        const { toolCall, args } = context;
-        // toolCall is an object with type "toolCall" and contains the tool name and ID
-        const toolName = (toolCall as any).toolName ?? (toolCall as any).name;
-        if (toolName && WRITE_TOOLS.has(toolName)) {
-          // Special handling for batch creations where we need to check multiple files
-          const pathsToCheck: string[] = [];
-          if (toolName === 'batch_create_files' && Array.isArray((args as any).files)) {
-            (args as any).files.forEach((f: any) => { if (f.path) pathsToCheck.push(f.path); });
-          } else {
-            const singlePath = (args as any).path ?? (args as any).from_path;
-            if (singlePath) pathsToCheck.push(singlePath);
-          }
+    const resourceLoader = new DefaultResourceLoader({
+      cwd: projectRoot,
+      settingsManager,
+      systemPromptOverride: () => systemPrompt,
+      appendSystemPromptOverride: () => [],
+      additionalSkillPaths: [
+        path.join(projectRoot, 'app', 'data', 'skills'),
+        path.join(projectRoot, 'skills'),
+        path.join(getMindRoot(), '.skills'),
+      ],
+    });
+    await resourceLoader.reload();
+
+    const { session } = await createAgentSession({
+      cwd: projectRoot,
+      model,
+      thinkingLevel: (enableThinking && provider === 'anthropic') ? 'medium' : 'off',
+      authStorage,
+      modelRegistry,
+      resourceLoader,
+      sessionManager: SessionManager.inMemory(),
+      settingsManager,
+      tools: [],
+      customTools,
+    });
 
-          for (const filePath of pathsToCheck) {
-            try {
-              assertNotProtected(filePath, 'modified by AI agent');
-            } catch (e) {
-              const errorMsg = e instanceof Error ? e.message : String(e);
-              return {
-                block: true,
-                reason: `Write-protection error: ${errorMsg}. You CANNOT modify ${filePath} because it is system-protected. Please tell the user you don't have permission to do this.`,
-              };
-            }
-          }
+    const llmHistoryMessages = convertToLlm(historyMessages);
+    await session.newSession({
+      setup: async (sessionManager) => {
+        for (const message of llmHistoryMessages) {
+          sessionManager.appendMessage(message);
         }
-        return undefined;
-      },
-
-      // Logging: record all tool executions
-      afterToolCall: async (context: AfterToolCallContext): Promise<AfterToolCallResult | undefined> => {
-        const ts = new Date().toISOString();
-        const { toolCall, args, result, isError } = context;
-        const toolName = (toolCall as any).toolName ?? (toolCall as any).name;
-        const outputText = result?.content
-          ?.filter((p: any) => p.type === 'text')
-          .map((p: any) => p.text)
-          .join('') ?? '';
-        try {
-          logAgentOp({
-            ts,
-            tool: toolName ?? 'unknown',
-            params: args as Record<string, unknown>,
-            result: isError ? 'error' : 'ok',
-            message: outputText.slice(0, 200),
-          });
-        } catch { /* logging must never kill the stream */ }
-        return undefined;
       },
-
-      ...(enableThinking && provider === 'anthropic' ? {
-        thinkingBudgets: { medium: thinkingBudget },
-      } : {}),
     });
 
+    // ── Loop detection state ──
+    const stepHistory: Array<{ tool: string; input: string }> = [];
+    let stepCount = 0;
+    let loopCooldown = 0;
+
     // ── SSE Stream ──
     const encoder = new TextEncoder();
     const requestStartTime = Date.now();
@@ -424,7 +458,7 @@ export async function POST(req: NextRequest) {
           } catch { /* controller may be closed */ }
         }
 
-        agent.subscribe((event: AgentEvent) => {
+        session.subscribe((event: AgentEvent) => {
           if (isTextDeltaEvent(event)) {
             send({ type: 'text_delta', delta: getTextDelta(event) });
           } else if (isThinkingDeltaEvent(event)) {
@@ -476,24 +510,20 @@ export async function POST(req: NextRequest) {
               if (lastN.every(s => s.tool === lastN[0].tool && s.input === lastN[0].input)) {
                 loopCooldown = 3;
                 // TODO (metrics): Track loop detection rate — metrics.increment('agent.loop_detected', { model: modelName })
-                agent.steer({
-                  role: 'user',
-                  content: '[SYSTEM WARNING] You have called the same tool with identical arguments 3 times in a row. This appears to be a loop. Try a completely different approach or ask the user for clarification.',
-                  timestamp: Date.now(),
-                } as any);
+                void session.steer('[SYSTEM WARNING] You have called the same tool with identical arguments 3 times in a row. This appears to be a loop. Try a completely different approach or ask the user for clarification.');
               }
             }
 
             // Step limit enforcement
             if (stepCount >= stepLimit) {
-              agent.abort();
+              void session.abort();
             }
 
             console.log(`[ask] Step ${stepCount}/${stepLimit}`);
           }
         });
 
-        agent.prompt(lastUserContent).then(() => {
+        session.prompt(lastUserContent).then(() => {
           metrics.recordRequest(Date.now() - requestStartTime);
           send({ type: 'done' });
           controller.close();

package/app/app/api/file/import/route.ts

@@ -0,0 +1,197 @@
+export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+
+import fs from 'fs';
+import path from 'path';
+import { NextRequest, NextResponse } from 'next/server';
+import { revalidatePath } from 'next/cache';
+import { sanitizeFileName, convertToMarkdown } from '@/lib/core/file-convert';
+import { resolveSafe } from '@/lib/core/security';
+import { scaffoldIfNewSpace } from '@/lib/core/space-scaffold';
+import { organizeAfterImport } from '@/lib/core/organize';
+import { invalidateSearchIndex } from '@/lib/core/search';
+import { effectiveSopRoot } from '@/lib/settings';
+import { invalidateCache } from '@/lib/fs';
+
+const MAX_FILES = 20;
+const MAX_CONTENT_LENGTH = 5 * 1024 * 1024;
+
+type ConflictMode = 'skip' | 'rename' | 'overwrite';
+
+interface ImportRequest {
+  files: Array<{
+    name: string;
+    content: string;
+    encoding?: 'text' | 'base64';
+  }>;
+  targetSpace?: string;
+  organize?: boolean;
+  conflict?: ConflictMode;
+}
+
+function normalizeTargetSpace(raw: unknown): string {
+  if (raw === undefined || raw === null) return '';
+  if (typeof raw !== 'string') return '';
+  return raw.replace(/\\/g, '/').replace(/^\/+/, '').replace(/\/+$/, '').trim();
+}
+
+function decodeFileContent(
+  encoding: 'text' | 'base64' | undefined,
+  content: string,
+  sanitizedName: string,
+): string {
+  if (encoding === 'base64') {
+    const buf = Buffer.from(content, 'base64');
+    if (sanitizedName.toLowerCase().endsWith('.pdf')) {
+      return buf.toString('latin1');
+    }
+    return buf.toString('utf-8');
+  }
+  return content;
+}
+
+function resolveUniquePath(
+  mindRoot: string,
+  relPath: string,
+  conflict: ConflictMode,
+): { relPath: string; resolved: string; skipped?: string } {
+  let rel = relPath.replace(/\\/g, '/');
+  let resolved = resolveSafe(mindRoot, rel);
+  if (!fs.existsSync(resolved)) {
+    return { relPath: rel, resolved };
+  }
+  if (conflict === 'skip') {
+    return { relPath: rel, resolved, skipped: 'file exists' };
+  }
+  if (conflict === 'overwrite') {
+    return { relPath: rel, resolved };
+  }
+  let n = 0;
+  while (fs.existsSync(resolved)) {
+    n += 1;
+    const dir = path.posix.dirname(rel);
+    const base = path.posix.basename(rel);
+    const ext = path.posix.extname(base);
+    const stem = ext ? base.slice(0, -ext.length) : base;
+    const newBase = `${stem}-${n}${ext}`;
+    rel = dir && dir !== '.' ? path.posix.join(dir, newBase) : newBase;
+    resolved = resolveSafe(mindRoot, rel);
+  }
+  return { relPath: rel, resolved };
+}
+
+export async function POST(req: NextRequest) {
+  let body: unknown;
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
+  }
+
+  const mindRoot = effectiveSopRoot().trim();
+  if (!mindRoot) {
+    return NextResponse.json({ error: 'MIND_ROOT is not configured' }, { status: 400 });
+  }
+
+  if (!body || typeof body !== 'object') {
+    return NextResponse.json({ error: 'Invalid request body' }, { status: 400 });
+  }
+
+  const reqBody = body as ImportRequest;
+  if (!Array.isArray(reqBody.files)) {
+    return NextResponse.json({ error: 'files must be an array' }, { status: 400 });
+  }
+
+  if (reqBody.files.length > MAX_FILES) {
+    return NextResponse.json({ error: `At most ${MAX_FILES} files per request` }, { status: 400 });
+  }
+
+  const targetSpaceNorm = normalizeTargetSpace(reqBody.targetSpace);
+  const organize = reqBody.organize !== false;
+  const conflict: ConflictMode =
+    reqBody.conflict === 'skip' || reqBody.conflict === 'overwrite' || reqBody.conflict === 'rename'
+      ? reqBody.conflict
+      : 'rename';
+
+  const created: Array<{ original: string; path: string }> = [];
+  const skipped: Array<{ name: string; reason: string }> = [];
+  const errors: Array<{ name: string; error: string }> = [];
+  const createdPaths: string[] = [];
+  const updatedFiles: string[] = [];
+
+  for (const entry of reqBody.files) {
+    const originalName = typeof entry?.name === 'string' ? entry.name : '';
+    try {
+      if (typeof entry?.name !== 'string' || typeof entry?.content !== 'string') {
+        errors.push({ name: originalName || '(unknown)', error: 'name and content must be strings' });
+        continue;
+      }
+      if (!entry.name.trim()) {
+        errors.push({ name: '(empty)', error: 'name must not be empty' });
+        continue;
+      }
+      if (entry.content.length > MAX_CONTENT_LENGTH) {
+        errors.push({ name: entry.name, error: `content exceeds ${MAX_CONTENT_LENGTH} characters` });
+        continue;
+      }
+
+      const sanitized = sanitizeFileName(entry.name);
+      const encoding = entry.encoding === 'base64' ? 'base64' : 'text';
+      const raw = decodeFileContent(encoding, entry.content, sanitized);
+      const convertResult = convertToMarkdown(sanitized, raw);
+
+      let relPath = targetSpaceNorm
+        ? path.posix.join(targetSpaceNorm, convertResult.targetName)
+        : convertResult.targetName;
+
+      const { relPath: finalRel, resolved, skipped: skipReason } = resolveUniquePath(
+        mindRoot,
+        relPath,
+        conflict,
+      );
+
+      if (skipReason) {
+        skipped.push({ name: entry.name, reason: skipReason });
+        continue;
+      }
+
+      fs.mkdirSync(path.dirname(resolved), { recursive: true });
+      fs.writeFileSync(resolved, convertResult.content, 'utf-8');
+      scaffoldIfNewSpace(mindRoot, finalRel);
+
+      created.push({ original: entry.name, path: finalRel });
+      createdPaths.push(finalRel);
+    } catch (e) {
+      errors.push({ name: originalName || '(unknown)', error: (e as Error).message });
+    }
+  }
+
+  if (organize && createdPaths.length > 0) {
+    try {
+      const { readmeUpdated } = organizeAfterImport(mindRoot, createdPaths, targetSpaceNorm);
+      if (readmeUpdated && targetSpaceNorm) {
+        updatedFiles.push(path.posix.join(targetSpaceNorm, 'README.md'));
+      }
+    } catch {
+      /* organize is best-effort */
+    }
+  }
+
+  if (created.length > 0 || updatedFiles.length > 0) {
+    invalidateSearchIndex();
+    invalidateCache();
+  }
+
+  try {
+    revalidatePath('/');
+  } catch {
+    /* noop in test env */
+  }
+
+  return NextResponse.json({
+    created,
+    skipped,
+    errors,
+    updatedFiles,
+  });
+}

package/app/app/api/mcp/agents/route.ts

@@ -1,4 +1,7 @@
 export const dynamic = 'force-dynamic';
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
 import { NextResponse } from 'next/server';
 import {
   MCP_AGENTS,
@@ -9,6 +12,50 @@ import {
   detectAgentInstalledSkills,
   resolveSkillWorkspaceProfile,
 } from '@/lib/mcp-agents';
+import { readSettings } from '@/lib/settings';
+import { scanSkillDirs } from '@/lib/pi-integration/skills';
+import { getMindRoot } from '@/lib/fs';
+
+function enrichMindOsAgent(agent: Record<string, unknown>) {
+  agent.present = true;
+  agent.installed = true;
+  agent.scope = 'builtin';
+
+  try {
+    const settings = readSettings();
+    const port = Number(process.env.MINDOS_MCP_PORT) || settings.mcpPort || 8781;
+    agent.transport = `http :${port}`;
+  } catch {
+    agent.transport = 'http :8781';
+  }
+
+  try {
+    const projectRoot = process.env.MINDOS_PROJECT_ROOT || path.resolve(process.cwd(), '..');
+    const skills = scanSkillDirs({ projectRoot, mindRoot: getMindRoot() });
+    const enabledSkills = skills.filter(s => s.enabled);
+    agent.installedSkillNames = enabledSkills.map(s => s.name);
+    agent.installedSkillCount = enabledSkills.length;
+    agent.installedSkillSourcePath = path.join(projectRoot, 'skills');
+    agent.skillMode = 'universal';
+    agent.skillWorkspacePath = path.join(os.homedir(), '.agents', 'skills');
+  } catch { /* skill scan unavailable */ }
+
+  const mcpConfigPath = path.join(os.homedir(), '.mindos', 'mcp.json');
+  try {
+    if (fs.existsSync(mcpConfigPath)) {
+      const raw = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf-8'));
+      const servers = Object.keys(raw.mcpServers ?? {});
+      agent.configuredMcpServers = servers;
+      agent.configuredMcpServerCount = servers.length;
+      agent.configuredMcpSources = servers.length > 0 ? [`local:${mcpConfigPath}`] : [];
+    }
+  } catch { /* ignore */ }
+
+  agent.runtimeConversationSignal = true;
+  agent.runtimeLastActivityAt = new Date().toISOString();
+  agent.hiddenRootPath = path.join(os.homedir(), '.mindos');
+  agent.hiddenRootPresent = true;
+}
 
 export async function GET() {
   try {
@@ -30,7 +77,6 @@ export async function GET() {
         hasProjectScope: !!agent.project,
         hasGlobalScope: !!agent.global,
         preferredTransport: agent.preferredTransport,
-        // Snippet generation fields
         format: agent.format ?? 'json',
         configKey: agent.key,
         globalNestedKey: agent.globalNestedKey,
@@ -53,8 +99,13 @@ export async function GET() {
       };
     });
 
-    // Sort: installed first, then detected, then not found
+    const mindos = agents.find(a => a.key === 'mindos');
+    if (mindos) enrichMindOsAgent(mindos as unknown as Record<string, unknown>);
+
+    // Sort: mindos first, then installed, then detected, then not found
     agents.sort((a, b) => {
+      if (a.key === 'mindos') return -1;
+      if (b.key === 'mindos') return 1;
       const rank = (x: typeof a) => x.installed ? 0 : x.present ? 1 : 2;
       return rank(a) - rank(b);
     });

package/app/app/api/mcp/status/route.ts

@@ -50,7 +50,7 @@ export async function GET(req: NextRequest) {
       transport: 'http',
       endpoint,
       port,
-      toolCount: running ? 23 : 0,
+      toolCount: running ? 24 : 0,
       authConfigured,
       // Masked for display; full token only used server-side in snippet generation
       maskedToken: authConfigured ? maskToken(token) : undefined,