@geminilight/mindos 0.1.0

package/app/lib/core/search.ts

@@ -0,0 +1,79 @@
+import fs from 'fs';
+import path from 'path';
+import { resolveSafe } from './security';
+import { collectAllFiles } from './tree';
+import { readFile } from './fs-ops';
+import type { SearchResult, SearchOptions } from './types';
+
+/**
+ * Core literal search — used by MCP tools via REST API.
+ *
+ * This is a **case-insensitive literal string match** with occurrence-density scoring.
+ * It supports scope, file_type, and modified_after filters that MCP tools expose.
+ *
+ * NOTE: The App also has a separate Fuse.js fuzzy search in `lib/fs.ts` for the
+ * browser `⌘K` search overlay. The two coexist intentionally:
+ * - Core search (here): exact literal match, supports filters, used by MCP/API
+ * - App search (lib/fs.ts): Fuse.js fuzzy match with CJK support, used by frontend
+ */
+export function searchFiles(mindRoot: string, query: string, opts: SearchOptions = {}): SearchResult[] {
+  if (!query.trim()) return [];
+  const { limit = 20, scope, file_type = 'all', modified_after } = opts;
+
+  let allFiles = collectAllFiles(mindRoot);
+
+  // Filter by scope (directory prefix)
+  if (scope) {
+    const normalizedScope = scope.endsWith('/') ? scope : scope + '/';
+    allFiles = allFiles.filter(f => f.startsWith(normalizedScope) || f === scope);
+  }
+
+  // Filter by file type
+  if (file_type !== 'all') {
+    const ext = `.${file_type}`;
+    allFiles = allFiles.filter(f => f.endsWith(ext));
+  }
+
+  // Filter by modification time
+  let mtimeThreshold = 0;
+  if (modified_after) {
+    mtimeThreshold = new Date(modified_after).getTime();
+    if (isNaN(mtimeThreshold)) mtimeThreshold = 0;
+  }
+
+  const results: SearchResult[] = [];
+  const lowerQuery = query.toLowerCase();
+  const escapedQuery = lowerQuery.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+  for (const filePath of allFiles) {
+    // Check mtime filter before reading content
+    if (mtimeThreshold > 0) {
+      try {
+        const abs = path.join(mindRoot, filePath);
+        const stat = fs.statSync(abs);
+        if (stat.mtimeMs < mtimeThreshold) continue;
+      } catch { continue; }
+    }
+
+    let content: string;
+    try { content = readFile(mindRoot, filePath); } catch { continue; }
+
+    const lowerContent = content.toLowerCase();
+    const index = lowerContent.indexOf(lowerQuery);
+    if (index === -1) continue;
+
+    const snippetStart = Math.max(0, index - 60);
+    const snippetEnd = Math.min(content.length, index + query.length + 60);
+    let snippet = content.slice(snippetStart, snippetEnd).replace(/\n/g, ' ').trim();
+    if (snippetStart > 0) snippet = '...' + snippet;
+    if (snippetEnd < content.length) snippet += '...';
+
+    const occurrences = (lowerContent.match(new RegExp(escapedQuery, 'g')) ?? []).length;
+    const score = occurrences / content.length;
+
+    results.push({ path: filePath, snippet, score, occurrences });
+  }
+
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, limit);
+}

package/app/lib/core/security.ts

@@ -0,0 +1,43 @@
+import path from 'path';
+
+/**
+ * Asserts that a resolved path is within the given root.
+ */
+export function assertWithinRoot(resolved: string, root: string): void {
+  if (!resolved.startsWith(root + path.sep) && resolved !== root) {
+    throw new Error('Access denied: path outside MIND_ROOT');
+  }
+}
+
+/**
+ * Resolves a relative file path against mindRoot and validates it is within bounds.
+ * Returns the resolved absolute path.
+ */
+export function resolveSafe(mindRoot: string, filePath: string): string {
+  const root = path.resolve(mindRoot);
+  const resolved = path.resolve(path.join(root, filePath));
+  assertWithinRoot(resolved, root);
+  return resolved;
+}
+
+const ROOT_PROTECTED_FILES = new Set(['INSTRUCTION.md']);
+
+/**
+ * Checks if a relative file path refers to a root-level protected file.
+ */
+export function isRootProtected(filePath: string): boolean {
+  const normalized = path.normalize(filePath);
+  return ROOT_PROTECTED_FILES.has(normalized);
+}
+
+/**
+ * Throws if the file is protected and cannot be modified via automated tools.
+ */
+export function assertNotProtected(filePath: string, operation: string): void {
+  if (isRootProtected(filePath)) {
+    throw new Error(
+      `Protected file: root "${filePath}" cannot be ${operation} via MCP. ` +
+      `This is a system kernel file (§7 of INSTRUCTION.md). Edit it manually or use a dedicated confirmation workflow.`
+    );
+  }
+}

package/app/lib/core/tree.ts

@@ -0,0 +1,113 @@
+import fs from 'fs';
+import path from 'path';
+import type { FileNode } from './types';
+
+const DEFAULT_IGNORED_DIRS = new Set(['.git', 'node_modules', 'app', '.next', '.DS_Store', 'mcp']);
+const DEFAULT_ALLOWED_EXTENSIONS = new Set(['.md', '.csv']);
+
+export interface TreeOptions {
+  ignoredDirs?: Set<string>;
+  allowedExtensions?: Set<string>;
+}
+
+/**
+ * Builds a recursive file tree from dirPath.
+ * Only includes files with allowed extensions and non-ignored directories.
+ */
+export function getFileTree(
+  mindRoot: string,
+  dirPath?: string,
+  opts: TreeOptions = {}
+): FileNode[] {
+  const root = path.resolve(mindRoot);
+  const dir = dirPath ?? root;
+  const ignoredDirs = opts.ignoredDirs ?? DEFAULT_IGNORED_DIRS;
+  const allowedExtensions = opts.allowedExtensions ?? DEFAULT_ALLOWED_EXTENSIONS;
+
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const nodes: FileNode[] = [];
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    const relativePath = path.relative(root, fullPath);
+
+    if (entry.isDirectory()) {
+      if (ignoredDirs.has(entry.name)) continue;
+      const children = getFileTree(mindRoot, fullPath, opts);
+      if (children.length > 0) {
+        nodes.push({ name: entry.name, path: relativePath, type: 'directory', children });
+      }
+    } else if (entry.isFile()) {
+      const ext = path.extname(entry.name).toLowerCase();
+      if (allowedExtensions.has(ext)) {
+        nodes.push({ name: entry.name, path: relativePath, type: 'file', extension: ext });
+      }
+    }
+  }
+
+  nodes.sort((a, b) => {
+    if (a.type !== b.type) return a.type === 'directory' ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+
+  return nodes;
+}
+
+/**
+ * Collects all file paths (relative to mindRoot) with allowed extensions.
+ */
+export function collectAllFiles(
+  mindRoot: string,
+  dirPath?: string,
+  opts: TreeOptions = {}
+): string[] {
+  const root = path.resolve(mindRoot);
+  const dir = dirPath ?? root;
+  const ignoredDirs = opts.ignoredDirs ?? DEFAULT_IGNORED_DIRS;
+  const allowedExtensions = opts.allowedExtensions ?? DEFAULT_ALLOWED_EXTENSIONS;
+
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const files: string[] = [];
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (ignoredDirs.has(entry.name)) continue;
+      files.push(...collectAllFiles(mindRoot, fullPath, opts));
+    } else if (entry.isFile()) {
+      const ext = path.extname(entry.name).toLowerCase();
+      if (allowedExtensions.has(ext)) {
+        files.push(path.relative(root, fullPath));
+      }
+    }
+  }
+  return files;
+}
+
+/**
+ * Renders a file tree as an ASCII tree string.
+ */
+export function renderTree(nodes: FileNode[], indent = ''): string {
+  const lines: string[] = [];
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const isLast = i === nodes.length - 1;
+    const prefix = indent + (isLast ? '└── ' : '├── ');
+    const childIndent = indent + (isLast ? '    ' : '│   ');
+    lines.push(prefix + node.name + (node.type === 'directory' ? '/' : ''));
+    if (node.children?.length) {
+      lines.push(renderTree(node.children, childIndent));
+    }
+  }
+  return lines.join('\n');
+}

package/app/lib/core/types.ts

@@ -0,0 +1,40 @@
+export interface FileNode {
+  name: string;
+  path: string;
+  type: 'file' | 'directory';
+  children?: FileNode[];
+  extension?: string;
+  mtime?: number;
+}
+
+export interface SearchResult {
+  path: string;
+  snippet: string;
+  score: number;
+  occurrences: number;
+}
+
+export interface BacklinkEntry {
+  source: string;
+  line: number;
+  context: string;
+}
+
+export interface SearchOptions {
+  limit?: number;
+  scope?: string;
+  file_type?: 'md' | 'csv' | 'all';
+  modified_after?: string;
+}
+
+export interface GitLogEntry {
+  hash: string;
+  date: string;
+  message: string;
+  author: string;
+}
+
+export interface MoveResult {
+  newPath: string;
+  affectedFiles: string[];
+}