@geminilight/mindos 0.5.69 → 0.6.0

package/app/components/settings/KnowledgeTab.tsx

@@ -7,11 +7,27 @@ import { Field, Input, EnvBadge, SectionLabel, Toggle } from './Primitives';
 import { apiFetch } from '@/lib/api';
 import { copyToClipboard } from '@/lib/clipboard';
 import { formatBytes, formatUptime } from '@/lib/format';
+import { setShowHiddenFiles } from '@/components/FileTree';
+import { scanExampleFilesAction, cleanupExamplesAction } from '@/lib/actions';
 
 export function KnowledgeTab({ data, setData, t }: KnowledgeTabProps) {
   const env = data.envOverrides ?? {};
   const k = t.settings.knowledge;
 
+  // Hidden files toggle
+  const [showHidden, setShowHidden] = useState(() =>
+    typeof window !== 'undefined' && localStorage.getItem('show-hidden-files') === 'true'
+  );
+
+  // Example files cleanup
+  const [exampleCount, setExampleCount] = useState<number | null>(null);
+  const [cleaningUp, setCleaningUp] = useState(false);
+  const [cleanupResult, setCleanupResult] = useState<number | null>(null);
+
+  useEffect(() => {
+    scanExampleFilesAction().then(r => setExampleCount(r.files.length)).catch(() => {});
+  }, []);
+
   // Guide state toggle
   const [guideActive, setGuideActive] = useState<boolean | null>(null);
   const [guideDismissed, setGuideDismissed] = useState(false);
@@ -130,6 +146,51 @@ export function KnowledgeTab({ data, setData, t }: KnowledgeTabProps) {
         />
       </Field>
 
+      <div className="flex items-center justify-between">
+        <div>
+          <div className="text-sm text-foreground">{k.showHiddenFiles}</div>
+          <div className="text-xs text-muted-foreground mt-0.5">{k.showHiddenFilesHint}</div>
+        </div>
+        <Toggle checked={showHidden} onChange={() => {
+          const next = !showHidden;
+          setShowHidden(next);
+          setShowHiddenFiles(next);
+        }} />
+      </div>
+
+      {exampleCount !== null && exampleCount > 0 && cleanupResult === null && (
+        <div className="flex items-center justify-between">
+          <div>
+            <div className="text-sm text-foreground">{k.cleanupExamples}</div>
+            <div className="text-xs text-muted-foreground mt-0.5">{k.cleanupExamplesHint}</div>
+          </div>
+          <button
+            onClick={async () => {
+              if (!confirm(k.cleanupExamplesConfirm(exampleCount))) return;
+              setCleaningUp(true);
+              const r = await cleanupExamplesAction();
+              setCleaningUp(false);
+              if (r.success) {
+                setCleanupResult(r.deleted);
+                setExampleCount(0);
+              }
+            }}
+            disabled={cleaningUp}
+            className="flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium rounded-lg border border-border text-muted-foreground hover:text-foreground hover:bg-muted transition-colors shrink-0 disabled:opacity-50"
+          >
+            {cleaningUp ? <Loader2 size={12} className="animate-spin" /> : <Trash2 size={12} />}
+            {k.cleanupExamplesButton}
+            <span className="ml-1 tabular-nums text-2xs opacity-70">{exampleCount}</span>
+          </button>
+        </div>
+      )}
+      {cleanupResult !== null && (
+        <div className="flex items-center gap-2 text-xs text-success">
+          <Check size={14} />
+          {k.cleanupExamplesDone(cleanupResult)}
+        </div>
+      )}
+
       <div className="border-t border-border pt-5">
         <SectionLabel>Security</SectionLabel>
       </div>

package/app/components/walkthrough/steps.ts

@@ -1,10 +1,9 @@
 /** Walkthrough step anchors — these data-walkthrough attributes are added to target components */
 export type WalkthroughAnchor =
-  | 'activity-bar'
   | 'files-panel'
   | 'ask-button'
-  | 'search-button'
-  | 'settings-button';
+  | 'agents-panel'
+  | 'echo-panel';
 
 export interface WalkthroughStep {
   anchor: WalkthroughAnchor;
@@ -12,10 +11,16 @@ export interface WalkthroughStep {
   position: 'right' | 'bottom';
 }
 
+/**
+ * 4-step value-driven walkthrough aligned with the Dual-Layer Wedge strategy:
+ *   0. Project Memory (foundation)
+ *   1. AI That Already Knows You (wedge)
+ *   2. Multi-Agent Sharing (differentiation)
+ *   3. Echo — Cognitive Compound Interest (retention seed)
+ */
 export const walkthroughSteps: WalkthroughStep[] = [
-  { anchor: 'activity-bar', position: 'right' },
   { anchor: 'files-panel', position: 'right' },
   { anchor: 'ask-button', position: 'right' },
-  { anchor: 'search-button', position: 'right' },
-  { anchor: 'settings-button', position: 'right' },
+  { anchor: 'agents-panel', position: 'right' },
+  { anchor: 'echo-panel', position: 'right' },
 ];

package/app/hooks/useFileImport.ts

@@ -0,0 +1,191 @@
+'use client';
+
+import { useState, useCallback, useRef } from 'react';
+import { ALLOWED_IMPORT_EXTENSIONS } from '@/lib/core/file-convert';
+
+export type ImportIntent = 'archive' | 'digest';
+export type ImportStep = 'select' | 'archive_config' | 'importing' | 'done';
+export type ConflictMode = 'skip' | 'rename' | 'overwrite';
+
+export interface ImportFile {
+  file: File;
+  name: string;
+  size: number;
+  content: string | null;
+  loading: boolean;
+  error: string | null;
+}
+
+const MAX_FILE_SIZE = 5 * 1024 * 1024;
+const MAX_PDF_SIZE = 12 * 1024 * 1024;
+const MAX_FILES = 20;
+
+function getExt(name: string): string {
+  const idx = name.lastIndexOf('.');
+  return idx >= 0 ? name.slice(idx).toLowerCase() : '';
+}
+
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+export function useFileImport() {
+  const [files, setFiles] = useState<ImportFile[]>([]);
+  const [step, setStep] = useState<ImportStep>('select');
+  const [intent, setIntent] = useState<ImportIntent>('archive');
+  const [targetSpace, setTargetSpace] = useState('');
+  const [conflict, setConflict] = useState<ConflictMode>('rename');
+  const [importing, setImporting] = useState(false);
+  const [result, setResult] = useState<{
+    created: Array<{ original: string; path: string }>;
+    skipped: Array<{ name: string; reason: string }>;
+    errors: Array<{ name: string; error: string }>;
+    updatedFiles: string[];
+  } | null>(null);
+  const inputRef = useRef<HTMLInputElement>(null);
+
+  const addFiles = useCallback(async (fileList: FileList | File[]) => {
+    const incoming = Array.from(fileList).slice(0, MAX_FILES);
+    const newFiles: ImportFile[] = [];
+
+    for (const file of incoming) {
+      const ext = getExt(file.name);
+      const maxSize = ext === '.pdf' ? MAX_PDF_SIZE : MAX_FILE_SIZE;
+
+      let error: string | null = null;
+      if (!ALLOWED_IMPORT_EXTENSIONS.has(ext)) {
+        error = 'unsupported';
+      } else if (file.size > maxSize) {
+        error = 'tooLarge';
+      }
+
+      newFiles.push({
+        file,
+        name: file.name,
+        size: file.size,
+        content: null,
+        loading: !error,
+        error,
+      });
+    }
+
+    setFiles(prev => {
+      const merged = [...prev];
+      for (const f of newFiles) {
+        const isDup = merged.some(m =>
+          m.name === f.name && m.size === f.size
+        );
+        if (!isDup && merged.length < MAX_FILES) merged.push(f);
+      }
+      return merged;
+    });
+
+    for (const f of newFiles) {
+      if (f.error) continue;
+      try {
+        const text = await f.file.text();
+        setFiles(prev => prev.map(p =>
+          p.name === f.name && p.size === f.size
+            ? { ...p, content: text, loading: false }
+            : p
+        ));
+      } catch {
+        setFiles(prev => prev.map(p =>
+          p.name === f.name && p.size === f.size
+            ? { ...p, loading: false, error: 'readFailed' }
+            : p
+        ));
+      }
+    }
+  }, []);
+
+  const removeFile = useCallback((index: number) => {
+    setFiles(prev => prev.filter((_, i) => i !== index));
+  }, []);
+
+  const clearFiles = useCallback(() => {
+    setFiles([]);
+    setStep('select');
+    setResult(null);
+  }, []);
+
+  const validFiles = files.filter(f => !f.error && f.content !== null);
+  const allReady = files.length > 0 && files.every(f => !f.loading);
+  const hasErrors = files.some(f => f.error);
+
+  const doArchive = useCallback(async () => {
+    if (validFiles.length === 0) return;
+    setImporting(true);
+    setStep('importing');
+
+    try {
+      const payload = {
+        files: validFiles.map(f => ({
+          name: f.name,
+          content: f.content!,
+        })),
+        targetSpace: targetSpace || undefined,
+        conflict,
+        organize: true,
+      };
+
+      const res = await fetch('/api/file/import', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+      });
+
+      const data = await res.json();
+      if (!res.ok) throw new Error(data.error || `HTTP ${res.status}`);
+
+      setResult(data);
+      setStep('done');
+    } catch (err) {
+      setResult({
+        created: [],
+        skipped: [],
+        errors: [{ name: '*', error: (err as Error).message }],
+        updatedFiles: [],
+      });
+      setStep('done');
+    } finally {
+      setImporting(false);
+    }
+  }, [validFiles, targetSpace, conflict]);
+
+  const reset = useCallback(() => {
+    setFiles([]);
+    setStep('select');
+    setIntent('archive');
+    setTargetSpace('');
+    setConflict('rename');
+    setImporting(false);
+    setResult(null);
+  }, []);
+
+  return {
+    files,
+    step,
+    intent,
+    targetSpace,
+    conflict,
+    importing,
+    result,
+    inputRef,
+    validFiles,
+    allReady,
+    hasErrors,
+    addFiles,
+    removeFile,
+    clearFiles,
+    setStep,
+    setIntent,
+    setTargetSpace,
+    setConflict,
+    doArchive,
+    reset,
+    formatSize,
+  };
+}

package/app/hooks/useFileUpload.ts

@@ -115,6 +115,16 @@ export function useFileUpload() {
     setUploadError('');
   }, []);
 
+  const injectFiles = useCallback((files: LocalAttachment[]) => {
+    setLocalAttachments(prev => {
+      const merged = [...prev];
+      for (const item of files) {
+        if (!merged.some(m => m.name === item.name)) merged.push(item);
+      }
+      return merged;
+    });
+  }, []);
+
   return {
     localAttachments,
     uploadError,
@@ -122,5 +132,6 @@ export function useFileUpload() {
     pickFiles,
     removeAttachment,
     clearAttachments,
+    injectFiles,
   };
 }

package/app/hooks/useMention.ts

@@ -27,19 +27,27 @@ export function useMention() {
   }, [loadFiles]);
 
   const updateMentionFromInput = useCallback(
-    (val: string) => {
-      const atIdx = val.lastIndexOf('@');
+    (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;
       }
-      const before = val[atIdx - 1];
-      if (atIdx > 0 && before !== ' ') {
+      if (atIdx > 0 && before[atIdx - 1] !== ' ' && before[atIdx - 1] !== '\n') {
         setMentionQuery(null);
         return;
       }
-      const query = val.slice(atIdx + 1).toLowerCase();
-      const filtered = allFiles.filter((f) => f.toLowerCase().includes(query)).slice(0, 30);
+      const query = before.slice(atIdx + 1);
+      if (query.includes(' ') || query.includes('\n')) {
+        setMentionQuery(null);
+        setMentionResults([]);
+        setMentionIndex(0);
+        return;
+      }
+      const q = query.toLowerCase();
+      const filtered = allFiles.filter((f) => f.toLowerCase().includes(q)).slice(0, 30);
       if (filtered.length === 0) {
         setMentionQuery(null);
         setMentionResults([]);

package/app/hooks/useSlashCommand.ts

@@ -0,0 +1,114 @@
+'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[] = allSkills
+        .filter((s) => s.name.toLowerCase().includes(q) || s.description.toLowerCase().includes(q))
+        .slice(0, 20)
+        .map((s) => ({ type: 'skill', 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/app/lib/actions.ts

@@ -1,7 +1,10 @@
 'use server';
 
-import { createFile, deleteFile, deleteDirectory, convertToSpace, renameFile, renameSpace, getMindRoot, invalidateCache } from '@/lib/fs';
-import { createSpaceFilesystem } from '@/lib/core/create-space';
+import fs from 'fs';
+import path from 'path';
+import { createFile, deleteFile, deleteDirectory, convertToSpace, renameFile, renameSpace, getMindRoot, invalidateCache, collectAllFiles } from '@/lib/fs';
+import { createSpaceFilesystem, generateReadmeTemplate } from '@/lib/core/create-space';
+import { INSTRUCTION_TEMPLATE, cleanDirName } from '@/lib/core/space-scaffold';
 import { revalidatePath } from 'next/cache';
 
 export async function createFileAction(dirPath: string, fileName: string): Promise<{ success: boolean; filePath?: string; error?: string }> {
@@ -112,3 +115,77 @@ export async function createSpaceAction(
     return { success: false, error: msg };
   }
 }
+
+/**
+ * Revert AI-generated space content back to scaffold templates.
+ * Called when user discards AI initialization from SpaceInitToast.
+ */
+export async function revertSpaceInitAction(
+  spacePath: string,
+  name: string,
+  description: string,
+): Promise<{ success: boolean; error?: string }> {
+  try {
+    const mindRoot = getMindRoot();
+    const absDir = path.resolve(mindRoot, spacePath);
+    if (!absDir.startsWith(mindRoot)) {
+      return { success: false, error: 'Invalid path' };
+    }
+
+    const readmePath = path.join(absDir, 'README.md');
+    const instructionPath = path.join(absDir, 'INSTRUCTION.md');
+
+    const readmeContent = generateReadmeTemplate(spacePath, name, description);
+    fs.writeFileSync(readmePath, readmeContent, 'utf-8');
+
+    const dirName = cleanDirName(name);
+    fs.writeFileSync(instructionPath, INSTRUCTION_TEMPLATE(dirName), 'utf-8');
+
+    invalidateCache();
+    revalidatePath('/', 'layout');
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : 'Failed to revert' };
+  }
+}
+
+const EXAMPLE_PREFIX = '🧪_example_';
+
+export async function scanExampleFilesAction(): Promise<{ files: string[] }> {
+  const all = collectAllFiles();
+  const examples = all.filter(f => path.basename(f).startsWith(EXAMPLE_PREFIX));
+  return { files: examples };
+}
+
+export async function cleanupExamplesAction(): Promise<{ success: boolean; deleted: number; error?: string }> {
+  try {
+    const { files } = await scanExampleFilesAction();
+    if (files.length === 0) return { success: true, deleted: 0 };
+
+    const root = getMindRoot();
+    for (const relPath of files) {
+      const absPath = path.resolve(root, relPath);
+      if (absPath.startsWith(root) && fs.existsSync(absPath)) {
+        fs.unlinkSync(absPath);
+      }
+    }
+
+    // Clean up empty directories left behind
+    const dirs = new Set(files.map(f => path.dirname(path.resolve(root, f))));
+    const sortedDirs = [...dirs].sort((a, b) => b.length - a.length);
+    for (const dir of sortedDirs) {
+      try {
+        if (dir.startsWith(root) && dir !== root) {
+          const entries = fs.readdirSync(dir);
+          if (entries.length === 0) fs.rmdirSync(dir);
+        }
+      } catch { /* directory not empty or already removed */ }
+    }
+
+    invalidateCache();
+    revalidatePath('/', 'layout');
+    return { success: true, deleted: files.length };
+  } catch (err) {
+    return { success: false, deleted: 0, error: err instanceof Error ? err.message : 'Failed to cleanup' };
+  }
+}

package/app/lib/agent/index.ts

@@ -1,5 +1,5 @@
 export { getModelConfig } from './model';
-export { knowledgeBaseTools, WRITE_TOOLS, truncate } from './tools';
+export { getRequestScopedTools, knowledgeBaseTools, WRITE_TOOLS, truncate } from './tools';
 export { AGENT_SYSTEM_PROMPT } from './prompt';
 export {
   estimateTokens, estimateStringTokens, getContextLimit, needsCompact,

package/app/lib/agent/prompt.ts

@@ -27,6 +27,8 @@ Persona: Methodical, strictly objective, execution-oriented. Zero fluff. Never u
 
 - **Auto-loaded**: Configs, instructions, and SKILL.md are already in your context. Do not search for them unless explicitly asked.
 - **Uploaded Files**: Local files attached by the user appear in the "⚠️ USER-UPLOADED FILES" section below. Use this content directly. Do NOT use tools to read/search them.
+- **Skills**: Use the list_skills and load_skill tools to discover available skills on demand.
+- **MCP**: The MindOS MCP server is built-in. Use list_mcp_tools and call_mcp_tool to inspect and invoke additional MCP tools configured in ~/.mindos/mcp.json.
 
 ## Output