@geminilight/mindos 0.5.69 → 0.6.0

package/app/lib/pi-integration/mcporter.ts

@@ -0,0 +1,219 @@
+import os from 'os';
+import path from 'path';
+import { Type } from '@sinclair/typebox';
+import type { AgentTool, AgentToolResult } from '@mariozechner/pi-agent-core';
+import {
+  createRuntime,
+  createCallResult,
+  type Runtime,
+  type ServerToolInfo,
+} from 'mcporter';
+
+export interface McporterServerSummary {
+  name: string;
+  status: string;
+  durationMs?: number;
+  transport?: string;
+  error?: string;
+  issue?: { kind?: string; rawMessage?: string };
+  source?: { kind?: string; path?: string; importKind?: string };
+  tools?: McporterToolSummary[];
+}
+
+export interface McporterToolSummary {
+  name: string;
+  description?: string;
+  inputSchema?: Record<string, unknown>;
+  options?: Array<Record<string, unknown>>;
+}
+
+export interface McporterServerList {
+  mode?: string;
+  counts?: Record<string, number>;
+  servers: McporterServerSummary[];
+}
+
+function textResult(text: string): AgentToolResult<Record<string, never>> {
+  return { content: [{ type: 'text', text }], details: {} };
+}
+
+function normalizeNameSegment(value: string): string {
+  const normalized = value.toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '');
+  return normalized || 'tool';
+}
+
+function toToolSchema(inputSchema?: Record<string, unknown>) {
+  if (!inputSchema || Object.keys(inputSchema).length === 0) {
+    return Type.Object({}, { additionalProperties: true });
+  }
+  return Type.Unsafe(inputSchema as any);
+}
+
+export function extractJsonObject(text: string): string {
+  const first = text.indexOf('{');
+  const last = text.lastIndexOf('}');
+  if (first === -1 || last === -1 || last < first) {
+    throw new Error('Failed to parse mcporter output as JSON');
+  }
+  return text.slice(first, last + 1);
+}
+
+// ─── Singleton mcporter Runtime ──────────────────────────────────────────────
+
+const MCP_CONFIG_PATH = path.join(os.homedir(), '.mindos', 'mcp.json');
+const TOOL_TIMEOUT_MS = 30_000;
+
+let _runtime: Runtime | null = null;
+let _runtimePromise: Promise<Runtime | null> | null = null;
+
+async function getRuntime(): Promise<Runtime | null> {
+  if (_runtime) return _runtime;
+  if (_runtimePromise) return _runtimePromise;
+
+  _runtimePromise = (async () => {
+    try {
+      const rt = await createRuntime({
+        configPath: MCP_CONFIG_PATH,
+        clientInfo: { name: 'mindos', version: '1.0.0' },
+      });
+      _runtime = rt;
+      return rt;
+    } catch (err) {
+      console.warn('[mcporter] Failed to create runtime:', err instanceof Error ? err.message : err);
+      _runtimePromise = null;
+      return null;
+    }
+  })();
+  return _runtimePromise;
+}
+
+if (typeof process !== 'undefined') {
+  const cleanup = () => {
+    if (_runtime) {
+      _runtime.close().catch(() => {});
+      _runtime = null;
+      _runtimePromise = null;
+    }
+  };
+  process.on('exit', cleanup);
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+}
+
+export async function listMcporterServers(): Promise<McporterServerList> {
+  const rt = await getRuntime();
+  if (!rt) return { servers: [] };
+
+  try {
+    const names = rt.listServers();
+    if (names.length === 0) return { servers: [] };
+
+    const servers: McporterServerSummary[] = await Promise.all(
+      names.map(async (name) => {
+        try {
+          const def = rt.getDefinition(name);
+          const transport = def.command.kind;
+          const tools = await rt.listTools(name, { includeSchema: false });
+          return {
+            name,
+            status: 'ok',
+            transport,
+            tools: tools.map(toToolSummary),
+          };
+        } catch (err) {
+          return {
+            name,
+            status: 'error',
+            error: err instanceof Error ? err.message : String(err),
+          };
+        }
+      }),
+    );
+
+    return { servers };
+  } catch (err) {
+    console.warn('[mcporter] listServers failed:', err instanceof Error ? err.message : err);
+    return { servers: [] };
+  }
+}
+
+function toToolSummary(tool: ServerToolInfo): McporterToolSummary {
+  return {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema as Record<string, unknown> | undefined,
+  };
+}
+
+export async function listMcporterTools(serverName: string): Promise<McporterServerSummary> {
+  const rt = await getRuntime();
+  if (!rt) return { name: serverName, status: 'not_configured', tools: [] };
+
+  try {
+    const tools = await rt.listTools(serverName, { includeSchema: true });
+    return {
+      name: serverName,
+      status: 'ok',
+      tools: tools.map(toToolSummary),
+    };
+  } catch (err) {
+    return {
+      name: serverName,
+      status: 'error',
+      error: err instanceof Error ? err.message : String(err),
+      tools: [],
+    };
+  }
+}
+
+export async function callMcporterTool(
+  serverName: string,
+  toolName: string,
+  args: Record<string, unknown>,
+): Promise<string> {
+  const rt = await getRuntime();
+  if (!rt) throw new Error(`MCP runtime not available. Ensure ~/.mindos/mcp.json is configured.`);
+
+  const raw = await rt.callTool(serverName, toolName, {
+    args,
+    timeoutMs: TOOL_TIMEOUT_MS,
+  });
+  const result = createCallResult(raw);
+  return result.text('\n') ?? JSON.stringify(raw);
+}
+
+export function createMcporterAgentTools(servers: McporterServerSummary[]): AgentTool<any>[] {
+  const seenNames = new Set<string>();
+  const tools: AgentTool<any>[] = [];
+
+  for (const server of servers) {
+    if (server.status !== 'ok' || !server.tools?.length) continue;
+
+    for (const tool of server.tools) {
+      const baseName = `mcp__${normalizeNameSegment(server.name)}__${normalizeNameSegment(tool.name)}`;
+      let name = baseName;
+      let suffix = 2;
+      while (seenNames.has(name)) {
+        name = `${baseName}_${suffix++}`;
+      }
+      seenNames.add(name);
+
+      tools.push({
+        name,
+        label: `MCP ${server.name}: ${tool.name}`,
+        description: `MCP tool "${tool.name}" from server "${server.name}".${tool.description ? ` ${tool.description}` : ''}`,
+        parameters: toToolSchema(tool.inputSchema),
+        execute: async (_toolCallId, params) => {
+          try {
+            const output = await callMcporterTool(server.name, tool.name, (params ?? {}) as Record<string, unknown>);
+            return textResult(output || '(empty MCP response)');
+          } catch (error) {
+            return textResult(`Error: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        },
+      });
+    }
+  }
+
+  return tools;
+}

package/app/lib/pi-integration/session-store.ts

@@ -0,0 +1,62 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { SessionManager } from '@mariozechner/pi-coding-agent';
+
+function getSessionsRoot(): string {
+  return path.join(os.homedir(), '.mindos', 'sessions');
+}
+
+export function getSessionDir(sessionId: string): string {
+  const safe = sessionId.replace(/[^a-zA-Z0-9_-]/g, '_');
+  return path.join(getSessionsRoot(), safe);
+}
+
+export function sessionDirExists(sessionId: string): boolean {
+  const sessionDir = getSessionDir(sessionId);
+  if (!fs.existsSync(sessionDir)) return false;
+  // Check if there's at least one .jsonl file
+  try {
+    return fs.readdirSync(sessionDir).some((f) => f.endsWith('.jsonl'));
+  } catch {
+    return false;
+  }
+}
+
+export function getOrCreateSessionManager(
+  sessionId: string | undefined,
+  cwd: string,
+): SessionManager {
+  if (!sessionId) {
+    return SessionManager.inMemory(cwd);
+  }
+
+  const sessionDir = getSessionDir(sessionId);
+
+  try {
+    fs.mkdirSync(sessionDir, { recursive: true });
+
+    if (sessionDirExists(sessionId)) {
+      // Reuse the most recent session in this directory
+      return SessionManager.continueRecent(cwd, sessionDir);
+    }
+
+    // Brand new — create fresh session file
+    return SessionManager.create(cwd, sessionDir);
+  } catch (error) {
+    console.error(`[session-store] Failed to open/create session ${sessionId}, falling back to inMemory:`, error);
+    return SessionManager.inMemory(cwd);
+  }
+}
+
+export function deleteSessionDir(sessionId: string): boolean {
+  const sessionDir = getSessionDir(sessionId);
+  if (!fs.existsSync(sessionDir)) return false;
+  try {
+    fs.rmSync(sessionDir, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    console.error(`[session-store] Failed to delete session dir ${sessionDir}:`, error);
+    return false;
+  }
+}

package/app/lib/pi-integration/skills.ts

@@ -0,0 +1,116 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+export interface PiSkillInfo {
+  name: string;
+  description: string;
+  path: string;
+  source: 'builtin' | 'user';
+  enabled: boolean;
+  editable: boolean;
+  origin: 'app-builtin' | 'project-builtin' | 'mindos-user' | 'mindos-global';
+}
+
+export interface ScanSkillOptions {
+  projectRoot: string;
+  mindRoot: string;
+  disabledSkills?: string[];
+}
+
+export function parseSkillMd(content: string): { name: string; description: string } {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return { name: '', description: '' };
+  const yaml = match[1];
+  const nameMatch = yaml.match(/^name:\s*(.+)/m);
+  const descMatch = yaml.match(/^description:\s*>?\s*\n?([\s\S]*?)(?=\n\w|\n---)/m);
+  const name = nameMatch ? nameMatch[1].trim() : '';
+  let description = '';
+  if (descMatch) {
+    description = descMatch[1].trim().split('\n').map((l) => l.trim()).join(' ').slice(0, 200);
+  } else {
+    const simpleDesc = yaml.match(/^description:\s*(.+)/m);
+    if (simpleDesc) description = simpleDesc[1].trim().slice(0, 200);
+  }
+  return { name, description };
+}
+
+export function getPiSkillSearchDirs(projectRoot: string, mindRoot: string) {
+  return [
+    {
+      origin: 'app-builtin' as const,
+      dir: path.join(projectRoot, 'app', 'data', 'skills'),
+      pathLabel: 'app/data/skills',
+      source: 'builtin' as const,
+      editable: false,
+    },
+    {
+      origin: 'project-builtin' as const,
+      dir: path.join(projectRoot, 'skills'),
+      pathLabel: 'skills',
+      source: 'builtin' as const,
+      editable: false,
+    },
+    {
+      origin: 'mindos-user' as const,
+      dir: path.join(mindRoot, '.skills'),
+      pathLabel: '{mindRoot}/.skills',
+      source: 'user' as const,
+      editable: true,
+    },
+    {
+      origin: 'mindos-global' as const,
+      dir: path.join(os.homedir(), '.mindos', 'skills'),
+      pathLabel: '~/.mindos/skills',
+      source: 'user' as const,
+      editable: true,
+    },
+  ];
+}
+
+export function scanSkillDirs(options: ScanSkillOptions): PiSkillInfo[] {
+  const { projectRoot, mindRoot, disabledSkills = [] } = options;
+  const skills: PiSkillInfo[] = [];
+  const seen = new Set<string>();
+
+  for (const sourceDef of getPiSkillSearchDirs(projectRoot, mindRoot)) {
+    if (!fs.existsSync(sourceDef.dir)) continue;
+
+    for (const entry of fs.readdirSync(sourceDef.dir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const skillFile = path.join(sourceDef.dir, entry.name, 'SKILL.md');
+      if (!fs.existsSync(skillFile)) continue;
+
+      const content = fs.readFileSync(skillFile, 'utf-8');
+      const { name, description } = parseSkillMd(content);
+      const skillName = name || entry.name;
+      if (!skillName || seen.has(skillName)) continue;
+
+      seen.add(skillName);
+      skills.push({
+        name: skillName,
+        description,
+        path: `${sourceDef.pathLabel}/${entry.name}/SKILL.md`,
+        source: sourceDef.source,
+        enabled: !disabledSkills.includes(skillName),
+        editable: sourceDef.editable,
+        origin: sourceDef.origin,
+      });
+    }
+  }
+
+  return skills;
+}
+
+export function readSkillContentByName(name: string, options: Omit<ScanSkillOptions, 'disabledSkills'>): string | null {
+  const { projectRoot, mindRoot } = options;
+
+  for (const sourceDef of getPiSkillSearchDirs(projectRoot, mindRoot)) {
+    const file = path.join(sourceDef.dir, name, 'SKILL.md');
+    if (fs.existsSync(file)) {
+      return fs.readFileSync(file, 'utf-8');
+    }
+  }
+
+  return null;
+}

package/app/lib/settings.ts

@@ -32,7 +32,7 @@ export interface GuideState {
   step1Done: boolean;     // 至少浏览过 1 个文件
   askedAI: boolean;       // 至少发过 1 条 AI 消息
   nextStepIndex: number;  // 0=C2, 1=C3, 2=C4, 3=全部完成
-  walkthroughStep?: number;     // -1=not started, 0-4=current step, 5=completed
+  walkthroughStep?: number;     // undefined=not started, 0-3=current step, 4=completed
   walkthroughDismissed?: boolean; // user skipped walkthrough
 }
 

package/app/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/types/routes.d.ts";
+import "./.next/dev/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/app/next.config.ts

@@ -3,7 +3,7 @@ import path from "path";
 
 const nextConfig: NextConfig = {
   transpilePackages: ['github-slugger'],
-  serverExternalPackages: ['chokidar', 'openai', '@mariozechner/pi-ai', '@mariozechner/pi-agent-core'],
+  serverExternalPackages: ['chokidar', 'openai', '@mariozechner/pi-ai', '@mariozechner/pi-agent-core', '@mariozechner/pi-coding-agent', 'mcporter'],
   output: 'standalone',
   outputFileTracingRoot: path.join(__dirname),
   turbopack: {

package/app/package.json

@@ -19,6 +19,7 @@
     "@codemirror/view": "^6.39.16",
     "@mariozechner/pi-agent-core": "^0.60.0",
     "@mariozechner/pi-ai": "^0.60.0",
+    "@mariozechner/pi-coding-agent": "^0.61.1",
     "@sinclair/typebox": "^0.34.33",
     "@tiptap/extension-image": "^3.20.1",
     "@tiptap/extension-link": "^3.20.1",
@@ -40,6 +41,7 @@
     "github-slugger": "^2.0.0",
     "lucide-react": "^0.577.0",
     "nanoid": "^5.1.0",
+    "mcporter": "^0.7.3",
     "next": "16.1.6",
     "papaparse": "^5.5.3",
     "pdfjs-dist": "^4.10.38",

package/mcp/src/index.ts

@@ -203,6 +203,35 @@ server.registerTool("mindos_create_file", {
   } catch (e) { logOp("mindos_create_file", { path }, "error", String(e)); return error(String(e)); }
 });
 
+// ── mindos_batch_create_files ────────────────────────────────────────────────
+
+server.registerTool("mindos_batch_create_files", {
+  title: "Batch Create Files",
+  description:
+    "Create multiple new files in a single operation. Only .md and .csv files allowed. Returns a summary of created files and any errors.",
+  inputSchema: z.object({
+    files: z.array(z.object({
+      path: z.string().min(1).regex(/\.(md|csv)$/).describe("Relative file path (must end in .md or .csv)"),
+      content: z.string().default("").describe("Initial file content"),
+    })).min(1).max(50).describe("List of files to create (max 50 per call)"),
+  }),
+}, async ({ files }) => {
+  const created: string[] = [];
+  const errors: string[] = [];
+  for (const file of files) {
+    try {
+      await post("/api/file", { op: "create_file", path: file.path, content: file.content });
+      created.push(file.path);
+    } catch (e) {
+      errors.push(`${file.path}: ${String(e)}`);
+    }
+  }
+  let msg = `Batch creation complete.\nCreated ${created.length} file(s): ${created.join(", ")}`;
+  if (errors.length > 0) msg += `\n\nFailed to create ${errors.length} file(s):\n${errors.join("\n")}`;
+  logOp("mindos_batch_create_files", { count: files.length }, created.length === files.length ? "ok" : "error", msg.slice(0, 200));
+  return created.length === files.length ? ok(msg) : error(msg);
+});
+
 // ── mindos_create_space ─────────────────────────────────────────────────────
 
 server.registerTool("mindos_create_space", {

package/package.json

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