50c 3.0.7 → 3.0.8

package/README.md

@@ -4,6 +4,8 @@
 
 AI developer tools from $0.01-$0.65 per call. No subscriptions.
 
+**Requirements:** Node.js 18+
+
 ## Quick Start
 
 ```bash
@@ -180,7 +182,6 @@ export FIFTYC_API_KEY=cv_xxx
 
 - Website: https://50c.ai
 - Docs: https://docs.50c.ai
-- GitHub: https://github.com/genxis/50c
 
 ---
 

package/bin/50c.js

@@ -617,10 +617,103 @@ function startMCPMode() {
 }
 
 async function handleMCPRequest(request) {
+  // Handle local file-memory tools first (FREE, no API call)
+  const localResult = await handleLocalTools(request);
+  if (localResult) return localResult;
+  
   // Forward to remote MCP endpoint
   return callRemoteMCP(request);
 }
 
+// Local file-memory tools (FREE, runs on user machine)
+const { FILE_TOOLS, indexFile, findSymbol, getLines, searchFile, fileSummary } = require('../lib/file-memory.js');
+
+const LOCAL_TOOLS = [
+  { name: "fm_index", description: "Index a large file for fast symbol/line lookup. Auto-detects Python/JS/TS. FREE.", inputSchema: { type: "object", properties: { filepath: { type: "string", description: "Absolute or relative path to file" } }, required: ["filepath"] } },
+  { name: "fm_find", description: "Find where a function/class is defined across all indexed files. FREE.", inputSchema: { type: "object", properties: { name: { type: "string", description: "Symbol name (function, class, variable)" }, filepath: { type: "string", description: "Optional: limit search to one file" } }, required: ["name"] } },
+  { name: "fm_lines", description: "Get specific line range from a file with line numbers. FREE.", inputSchema: { type: "object", properties: { filepath: { type: "string" }, start: { type: "number", description: "Start line number" }, end: { type: "number", description: "End line number" } }, required: ["filepath", "start", "end"] } },
+  { name: "fm_search", description: "Search for symbols and content in a file. Auto-indexes if needed. FREE.", inputSchema: { type: "object", properties: { filepath: { type: "string" }, query: { type: "string", description: "Search term" } }, required: ["filepath", "query"] } },
+  { name: "fm_summary", description: "Get summary of a file: line count, all functions, classes. FREE.", inputSchema: { type: "object", properties: { filepath: { type: "string" } }, required: ["filepath"] } },
+  { name: "fm_list", description: "List all indexed files with stats. FREE.", inputSchema: { type: "object", properties: {} } },
+  { name: "fm_context", description: "Get context around a symbol (function body, class methods). FREE.", inputSchema: { type: "object", properties: { filepath: { type: "string" }, symbol: { type: "string", description: "Function or class name" }, lines_after: { type: "number", description: "Lines to include after definition (default 50)" } }, required: ["filepath", "symbol"] } }
+];
+
+async function handleLocalTools(request) {
+  const { id, method, params } = request;
+  
+  // Handle tools/list - merge local + remote
+  if (method === 'tools/list') {
+    try {
+      const remote = await callRemoteMCP(request);
+      const remoteTools = remote.result?.tools || [];
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: { tools: [...LOCAL_TOOLS, ...remoteTools] }
+      };
+    } catch (e) {
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: { tools: LOCAL_TOOLS }
+      };
+    }
+  }
+  
+  // Handle local tool calls
+  if (method === 'tools/call') {
+    const { name, arguments: args } = params || {};
+    
+    if (name === 'fm_index') {
+      return mcpResult(id, indexFile(args.filepath));
+    }
+    if (name === 'fm_find') {
+      return mcpResult(id, findSymbol(args.name, args.filepath));
+    }
+    if (name === 'fm_lines') {
+      return mcpResult(id, getLines(args.filepath, args.start, args.end));
+    }
+    if (name === 'fm_search') {
+      return mcpResult(id, searchFile(args.filepath, args.query));
+    }
+    if (name === 'fm_summary') {
+      return mcpResult(id, fileSummary(args.filepath));
+    }
+    if (name === 'fm_list') {
+      const fs = require('fs');
+      const INDEX_DIR = path.join(os.homedir(), '.50c', 'file_index');
+      if (!fs.existsSync(INDEX_DIR)) return mcpResult(id, []);
+      const files = fs.readdirSync(INDEX_DIR).filter(f => f.endsWith('.json'));
+      const results = [];
+      for (const file of files) {
+        try {
+          const index = JSON.parse(fs.readFileSync(path.join(INDEX_DIR, file), 'utf8'));
+          results.push({ filename: index.filename, filepath: index.filepath, lines: index.totalLines, symbols: index.symbols?.length || 0 });
+        } catch (e) {}
+      }
+      return mcpResult(id, results.sort((a, b) => b.lines - a.lines));
+    }
+    if (name === 'fm_context') {
+      const symbols = findSymbol(args.symbol, args.filepath);
+      if (symbols.length === 0) return mcpResult(id, { error: `Symbol not found: ${args.symbol}` });
+      const sym = symbols[0];
+      const linesAfter = args.lines_after || 50;
+      return mcpResult(id, { symbol: sym, content: getLines(sym.filepath, sym.line, sym.line + linesAfter) });
+    }
+  }
+  
+  return null; // Not a local tool, forward to remote
+}
+
+function mcpResult(id, result) {
+  const text = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+  return {
+    jsonrpc: '2.0',
+    id,
+    result: { content: [{ type: 'text', text }] }
+  };
+}
+
 // ═══════════════════════════════════════════════════════════════
 //                       API HELPERS
 // ═══════════════════════════════════════════════════════════════

package/lib/caz-context.js

@@ -0,0 +1,461 @@
+#!/usr/bin/env node
+/**
+ * 50c-context - Thin client for CAZ context compression
+ * 
+ * LOCAL (FREE): Basic indexing, hash lookup, line retrieval
+ * API (PRO): CAZ dedup, SimHash, BM25 ranking, fog detection
+ * 
+ * User sees this. Secret sauce stays on server.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const os = require('os');
+
+const INDEX_DIR = path.join(os.homedir(), '.50c', 'context');
+const API_BASE = process.env.FIFTYC_API_URL || 'https://api.50c.ai';
+
+if (!fs.existsSync(INDEX_DIR)) {
+  fs.mkdirSync(INDEX_DIR, { recursive: true });
+}
+
+function hash(content) {
+  return crypto.createHash('blake2b512').update(content).digest('hex').slice(0, 32);
+}
+
+function hashPath(filepath) {
+  return crypto.createHash('md5').update(filepath).digest('hex').slice(0, 12);
+}
+
+function getIndexPath(filepath) {
+  return path.join(INDEX_DIR, `${hashPath(filepath)}.json`);
+}
+
+function simpleChunk(content, targetSize = 1024) {
+  const chunks = [];
+  let start = 0;
+  while (start < content.length) {
+    let end = Math.min(start + targetSize, content.length);
+    if (end < content.length) {
+      const newline = content.lastIndexOf('\n', end);
+      if (newline > start + targetSize / 2) end = newline + 1;
+    }
+    chunks.push({
+      content: content.slice(start, end),
+      start,
+      end,
+      hash: hash(content.slice(start, end))
+    });
+    start = end;
+  }
+  return chunks;
+}
+
+function extractSymbols(lines, ext) {
+  const symbols = [];
+  const isPython = ['.py'].includes(ext);
+  const isJS = ['.js', '.ts', '.jsx', '.tsx', '.mjs'].includes(ext);
+  
+  lines.forEach((line, i) => {
+    const trimmed = line.trim();
+    const lineNum = i + 1;
+    
+    if (isPython) {
+      if (trimmed.startsWith('def ')) {
+        const name = trimmed.slice(4).split('(')[0].trim();
+        symbols.push({ name, type: 'function', line: lineNum });
+      }
+      else if (trimmed.startsWith('async def ')) {
+        const name = trimmed.slice(10).split('(')[0].trim();
+        symbols.push({ name, type: 'async_function', line: lineNum });
+      }
+      else if (trimmed.startsWith('class ')) {
+        const name = trimmed.slice(6).split('(')[0].split(':')[0].trim();
+        symbols.push({ name, type: 'class', line: lineNum });
+      }
+    }
+    
+    if (isJS) {
+      if (trimmed.match(/^(export\s+)?(async\s+)?function\s+\w+/)) {
+        const match = trimmed.match(/function\s+(\w+)/);
+        if (match) symbols.push({ name: match[1], type: 'function', line: lineNum });
+      }
+      else if (trimmed.match(/^(export\s+)?class\s+\w+/)) {
+        const match = trimmed.match(/class\s+(\w+)/);
+        if (match) symbols.push({ name: match[1], type: 'class', line: lineNum });
+      }
+      else if (trimmed.match(/^(export\s+)?(const|let|var)\s+\w+\s*=\s*(async\s+)?(\(|function)/)) {
+        const match = trimmed.match(/(const|let|var)\s+(\w+)/);
+        if (match) symbols.push({ name: match[2], type: 'arrow_fn', line: lineNum });
+      }
+    }
+  });
+  
+  return symbols;
+}
+
+function indexFile(filepath) {
+  filepath = path.resolve(filepath);
+  if (!fs.existsSync(filepath)) return { error: `File not found: ${filepath}` };
+  
+  const content = fs.readFileSync(filepath, 'utf8');
+  const lines = content.split('\n');
+  const ext = path.extname(filepath).toLowerCase();
+  const symbols = extractSymbols(lines, ext);
+  const chunks = simpleChunk(content);
+  const fileHash = hash(content);
+  
+  const indexPath = getIndexPath(filepath);
+  if (fs.existsSync(indexPath)) {
+    try {
+      const existing = JSON.parse(fs.readFileSync(indexPath, 'utf8'));
+      if (existing.hash === fileHash) {
+        return { status: 'current', filepath, lines: lines.length };
+      }
+    } catch (e) {}
+  }
+  
+  const blockHashes = {};
+  chunks.forEach(c => {
+    if (!blockHashes[c.hash]) blockHashes[c.hash] = [];
+    blockHashes[c.hash].push({ start: c.start, end: c.end });
+  });
+  
+  const index = {
+    filepath,
+    filename: path.basename(filepath),
+    hash: fileHash,
+    totalLines: lines.length,
+    indexed: new Date().toISOString(),
+    symbols,
+    chunks: chunks.map(c => ({ hash: c.hash, start: c.start, end: c.end })),
+    uniqueBlocks: Object.keys(blockHashes).length,
+    totalBlocks: chunks.length,
+    dedupRatio: chunks.length / Object.keys(blockHashes).length
+  };
+  
+  fs.writeFileSync(indexPath, JSON.stringify(index, null, 2));
+  
+  return {
+    status: 'indexed',
+    filepath,
+    lines: lines.length,
+    symbols: symbols.length,
+    uniqueBlocks: index.uniqueBlocks,
+    totalBlocks: index.totalBlocks,
+    dedupRatio: index.dedupRatio.toFixed(2)
+  };
+}
+
+function findSymbol(name, filepath = null) {
+  const indexFiles = filepath 
+    ? [getIndexPath(path.resolve(filepath))]
+    : fs.readdirSync(INDEX_DIR).filter(f => f.endsWith('.json')).map(f => path.join(INDEX_DIR, f));
+  
+  const results = [];
+  const nameLower = name.toLowerCase();
+  
+  for (const indexFile of indexFiles) {
+    if (!fs.existsSync(indexFile)) continue;
+    try {
+      const index = JSON.parse(fs.readFileSync(indexFile, 'utf8'));
+      const matches = index.symbols.filter(s => 
+        s.name.toLowerCase().includes(nameLower)
+      );
+      matches.forEach(m => results.push({ 
+        name: m.name, type: m.type, line: m.line,
+        file: index.filename, filepath: index.filepath
+      }));
+    } catch (e) {}
+  }
+  
+  return results.sort((a, b) => {
+    const aExact = a.name.toLowerCase() === nameLower ? 0 : 1;
+    const bExact = b.name.toLowerCase() === nameLower ? 0 : 1;
+    return aExact - bExact || a.line - b.line;
+  });
+}
+
+function getLines(filepath, start, end) {
+  filepath = path.resolve(filepath);
+  if (!fs.existsSync(filepath)) return { error: `File not found: ${filepath}` };
+  
+  const lines = fs.readFileSync(filepath, 'utf8').split('\n');
+  start = Math.max(1, start);
+  end = Math.min(lines.length, end);
+  
+  const result = [];
+  for (let i = start - 1; i < end; i++) {
+    result.push(`${(i + 1).toString().padStart(5)}| ${lines[i]}`);
+  }
+  return result.join('\n');
+}
+
+function getBlocksByQuery(filepath, query) {
+  filepath = path.resolve(filepath);
+  const indexPath = getIndexPath(filepath);
+  
+  if (!fs.existsSync(indexPath)) indexFile(filepath);
+  if (!fs.existsSync(indexPath)) return { error: `Could not index: ${filepath}` };
+  
+  const index = JSON.parse(fs.readFileSync(indexPath, 'utf8'));
+  const content = fs.readFileSync(filepath, 'utf8');
+  const queryLower = query.toLowerCase();
+  
+  const relevantSymbols = index.symbols.filter(s => 
+    s.name.toLowerCase().includes(queryLower)
+  );
+  
+  const relevantChunks = [];
+  const lines = content.split('\n');
+  
+  for (const sym of relevantSymbols) {
+    const startLine = sym.line;
+    let endLine = startLine + 50;
+    for (let i = startLine; i < Math.min(startLine + 100, lines.length); i++) {
+      const line = lines[i];
+      if (line && !line.startsWith(' ') && !line.startsWith('\t') && line.trim() && i > startLine) {
+        endLine = i;
+        break;
+      }
+    }
+    relevantChunks.push({
+      symbol: sym.name,
+      startLine,
+      endLine,
+      content: lines.slice(startLine - 1, endLine).join('\n')
+    });
+  }
+  
+  return {
+    query,
+    file: index.filename,
+    matchedSymbols: relevantSymbols.length,
+    chunks: relevantChunks.slice(0, 10),
+    totalLines: index.totalLines,
+    sentLines: relevantChunks.reduce((sum, c) => sum + (c.endLine - c.startLine), 0),
+    reduction: ((1 - relevantChunks.reduce((sum, c) => sum + (c.endLine - c.startLine), 0) / index.totalLines) * 100).toFixed(1) + '%'
+  };
+}
+
+async function apiCall(endpoint, data, apiKey) {
+  const key = apiKey || process.env.FIFTYC_API_KEY;
+  if (!key) return { error: 'No API key. Set FIFTYC_API_KEY' };
+  
+  try {
+    const fetch = globalThis.fetch || require('node-fetch');
+    const res = await fetch(`${API_BASE}${endpoint}`, {
+      method: 'POST',
+      headers: { 
+        'Content-Type': 'application/json',
+        'X-API-Key': key
+      },
+      body: JSON.stringify(data)
+    });
+    return await res.json();
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+async function cazDedup(filepath, apiKey) {
+  filepath = path.resolve(filepath);
+  if (!fs.existsSync(filepath)) return { error: `File not found: ${filepath}` };
+  
+  const content = fs.readFileSync(filepath, 'utf8');
+  const localIndex = indexFile(filepath);
+  
+  return await apiCall('/tools/caz_dedup', {
+    filepath: path.basename(filepath),
+    content,
+    localStats: localIndex
+  }, apiKey);
+}
+
+async function contextCompress(filepath, query, apiKey) {
+  filepath = path.resolve(filepath);
+  if (!fs.existsSync(filepath)) return { error: `File not found: ${filepath}` };
+  
+  const content = fs.readFileSync(filepath, 'utf8');
+  const localBlocks = getBlocksByQuery(filepath, query);
+  
+  return await apiCall('/tools/context_compress', {
+    filepath: path.basename(filepath),
+    query,
+    localBlocks,
+    content
+  }, apiKey);
+}
+
+async function fogCheck(messages, apiKey) {
+  return await apiCall('/tools/fog_check', { messages }, apiKey);
+}
+
+async function fogClear(messages, mode, apiKey) {
+  return await apiCall('/tools/fog_clear', { messages, mode }, apiKey);
+}
+
+function listIndexed() {
+  const files = fs.readdirSync(INDEX_DIR).filter(f => f.endsWith('.json'));
+  const results = [];
+  
+  for (const file of files) {
+    try {
+      const index = JSON.parse(fs.readFileSync(path.join(INDEX_DIR, file), 'utf8'));
+      results.push({
+        filename: index.filename,
+        filepath: index.filepath,
+        lines: index.totalLines,
+        symbols: index.symbols.length,
+        dedupRatio: index.dedupRatio?.toFixed(2) || 'N/A'
+      });
+    } catch (e) {}
+  }
+  
+  return results.sort((a, b) => b.lines - a.lines);
+}
+
+function stats() {
+  const files = listIndexed();
+  const totalLines = files.reduce((sum, f) => sum + f.lines, 0);
+  const totalSymbols = files.reduce((sum, f) => sum + f.symbols, 0);
+  
+  return {
+    indexedFiles: files.length,
+    totalLines,
+    totalSymbols,
+    indexDir: INDEX_DIR
+  };
+}
+
+const CONTEXT_TOOLS = {
+  ctx_index: {
+    description: "Index file for CAZ context compression. FREE.",
+    handler: (args) => indexFile(args.filepath)
+  },
+  ctx_find: {
+    description: "Find symbol across indexed files. FREE.",
+    handler: (args) => findSymbol(args.name, args.filepath)
+  },
+  ctx_lines: {
+    description: "Get specific line range. FREE.",
+    handler: (args) => getLines(args.filepath, args.start, args.end)
+  },
+  ctx_blocks: {
+    description: "Get relevant blocks for query. FREE.",
+    handler: (args) => getBlocksByQuery(args.filepath, args.query)
+  },
+  ctx_list: {
+    description: "List indexed files. FREE.",
+    handler: () => listIndexed()
+  },
+  ctx_stats: {
+    description: "Get indexing stats. FREE.",
+    handler: () => stats()
+  },
+  caz_dedup: {
+    description: "Full CAZ deduplication. PRO $0.02.",
+    handler: async (args) => await cazDedup(args.filepath, args.apiKey)
+  },
+  context_compress: {
+    description: "Compress context for query. PRO $0.03.",
+    handler: async (args) => await contextCompress(args.filepath, args.query, args.apiKey)
+  },
+  fog_check: {
+    description: "Check fog level. FREE.",
+    handler: async (args) => await fogCheck(args.messages, args.apiKey)
+  },
+  fog_clear: {
+    description: "Clear context fog. PRO $0.03.",
+    handler: async (args) => await fogClear(args.messages, args.mode, args.apiKey)
+  }
+};
+
+module.exports = {
+  CONTEXT_TOOLS,
+  indexFile,
+  findSymbol,
+  getLines,
+  getBlocksByQuery,
+  listIndexed,
+  stats,
+  cazDedup,
+  contextCompress,
+  fogCheck,
+  fogClear
+};
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const cmd = args[0];
+  
+  if (!cmd || cmd === 'help') {
+    console.log(`
+50c-context - CAZ Context Compression
+
+LOCAL (FREE):
+  ctx_index <file>          Index file for dedup
+  ctx_find <name> [file]    Find symbol
+  ctx_lines <file> <s> <e>  Get line range
+  ctx_blocks <file> <query> Get relevant blocks
+  ctx_list                  List indexed files
+  ctx_stats                 Show stats
+
+API (PRO):
+  caz_dedup <file>          Full CAZ deduplication
+  context_compress <f> <q>  Compress for query
+  fog_check                 Check fog level
+  fog_clear                 Clear context fog
+
+Test:
+  node caz-context.js test
+`);
+    return;
+  }
+  
+  if (cmd === 'test') {
+    const testFile = 'C:\\Users\\Administrator\\Desktop\\50c\\nj-deploy\\api-unified-v8-FINAL-ALL.py';
+    
+    console.log('='.repeat(60));
+    console.log('50c-context TEST');
+    console.log('='.repeat(60));
+    
+    console.log('\n[1] Indexing...');
+    const idx = indexFile(testFile);
+    console.log(idx);
+    
+    console.log('\n[2] Find fog_check...');
+    console.log(findSymbol('fog_check'));
+    
+    console.log('\n[3] Get blocks for "fog"...');
+    const blocks = getBlocksByQuery(testFile, 'fog');
+    console.log(`Matched: ${blocks.matchedSymbols} symbols`);
+    console.log(`Sent: ${blocks.sentLines} lines (${blocks.reduction} reduction)`);
+    console.log(`First chunk: ${blocks.chunks[0]?.symbol} at line ${blocks.chunks[0]?.startLine}`);
+    
+    console.log('\n[4] Stats...');
+    console.log(stats());
+    
+    console.log('\n[5] List indexed...');
+    console.log(listIndexed());
+  }
+  else if (cmd === 'index') {
+    console.log(indexFile(args[1]));
+  }
+  else if (cmd === 'find') {
+    console.log(JSON.stringify(findSymbol(args[1], args[2]), null, 2));
+  }
+  else if (cmd === 'lines') {
+    console.log(getLines(args[1], parseInt(args[2]), parseInt(args[3])));
+  }
+  else if (cmd === 'blocks') {
+    console.log(JSON.stringify(getBlocksByQuery(args[1], args[2]), null, 2));
+  }
+  else if (cmd === 'list') {
+    console.log(JSON.stringify(listIndexed(), null, 2));
+  }
+  else if (cmd === 'stats') {
+    console.log(JSON.stringify(stats(), null, 2));
+  }
+}

package/lib/file-memory.js

@@ -0,0 +1,301 @@
+/**
+ * FILE MEMORY - Local file indexing for LLM assistance
+ * No dependencies, pure Node.js
+ * 
+ * Helps LLM not "phone it in" on 4000-8000 line files by providing:
+ * - Function/class locations
+ * - Line range retrieval
+ * - Keyword search
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const INDEX_DIR = path.join(os.homedir(), '.50c', 'file_index');
+
+// Ensure index directory exists
+if (!fs.existsSync(INDEX_DIR)) {
+  fs.mkdirSync(INDEX_DIR, { recursive: true });
+}
+
+function getIndexPath(filepath) {
+  const hash = require('crypto').createHash('md5')
+    .update(filepath).digest('hex').slice(0, 12);
+  return path.join(INDEX_DIR, `${hash}.json`);
+}
+
+function extractSymbols(lines) {
+  const symbols = [];
+  lines.forEach((line, i) => {
+    const trimmed = line.trim();
+    const lineNum = i + 1;
+    
+    // Python
+    if (trimmed.startsWith('def ')) {
+      const name = trimmed.slice(4).split('(')[0].trim();
+      symbols.push({ name, type: 'function', line: lineNum, sig: trimmed.split(':')[0] });
+    }
+    else if (trimmed.startsWith('async def ')) {
+      const name = trimmed.slice(10).split('(')[0].trim();
+      symbols.push({ name, type: 'async_function', line: lineNum, sig: trimmed.split(':')[0] });
+    }
+    else if (trimmed.startsWith('class ')) {
+      const name = trimmed.slice(6).split('(')[0].split(':')[0].trim();
+      symbols.push({ name, type: 'class', line: lineNum, sig: trimmed.split(':')[0] });
+    }
+    // JavaScript/TypeScript
+    else if (trimmed.match(/^(export\s+)?(async\s+)?function\s+\w+/)) {
+      const match = trimmed.match(/function\s+(\w+)/);
+      if (match) symbols.push({ name: match[1], type: 'function', line: lineNum, sig: trimmed.split('{')[0].trim() });
+    }
+    else if (trimmed.match(/^(export\s+)?class\s+\w+/)) {
+      const match = trimmed.match(/class\s+(\w+)/);
+      if (match) symbols.push({ name: match[1], type: 'class', line: lineNum, sig: trimmed.split('{')[0].trim() });
+    }
+    else if (trimmed.match(/^(const|let|var)\s+\w+\s*=\s*(async\s+)?\(/)) {
+      const match = trimmed.match(/^(const|let|var)\s+(\w+)/);
+      if (match) symbols.push({ name: match[2], type: 'arrow_function', line: lineNum, sig: trimmed.slice(0, 60) });
+    }
+  });
+  return symbols;
+}
+
+function indexFile(filepath) {
+  filepath = path.resolve(filepath);
+  
+  if (!fs.existsSync(filepath)) {
+    return { error: `File not found: ${filepath}` };
+  }
+  
+  const content = fs.readFileSync(filepath, 'utf8');
+  const lines = content.split('\n');
+  const symbols = extractSymbols(lines);
+  
+  // Create chunks (100 lines each)
+  const chunkSize = 100;
+  const chunks = [];
+  for (let i = 0; i < lines.length; i += chunkSize) {
+    const chunkLines = lines.slice(i, i + chunkSize);
+    const chunkSymbols = symbols.filter(s => s.line > i && s.line <= i + chunkSize);
+    chunks.push({
+      start: i + 1,
+      end: Math.min(i + chunkSize, lines.length),
+      preview: chunkLines.slice(0, 3).join(' ').slice(0, 100),
+      functions: chunkSymbols.filter(s => s.type !== 'class').map(s => s.name),
+      classes: chunkSymbols.filter(s => s.type === 'class').map(s => s.name)
+    });
+  }
+  
+  const index = {
+    filepath,
+    totalLines: lines.length,
+    indexed: new Date().toISOString(),
+    symbols,
+    chunks
+  };
+  
+  fs.writeFileSync(getIndexPath(filepath), JSON.stringify(index, null, 2));
+  
+  return {
+    status: 'indexed',
+    filepath,
+    lines: lines.length,
+    functions: symbols.filter(s => s.type !== 'class').length,
+    classes: symbols.filter(s => s.type === 'class').length
+  };
+}
+
+function findSymbol(name, filepath = null) {
+  const files = filepath ? [getIndexPath(path.resolve(filepath))] : 
+    fs.readdirSync(INDEX_DIR).map(f => path.join(INDEX_DIR, f));
+  
+  const results = [];
+  for (const indexFile of files) {
+    if (!fs.existsSync(indexFile)) continue;
+    try {
+      const index = JSON.parse(fs.readFileSync(indexFile, 'utf8'));
+      const matches = index.symbols.filter(s => 
+        s.name.toLowerCase().includes(name.toLowerCase())
+      );
+      matches.forEach(m => results.push({ ...m, filepath: index.filepath }));
+    } catch (e) {}
+  }
+  return results;
+}
+
+function getLines(filepath, start, end) {
+  filepath = path.resolve(filepath);
+  if (!fs.existsSync(filepath)) {
+    return { error: `File not found: ${filepath}` };
+  }
+  
+  const lines = fs.readFileSync(filepath, 'utf8').split('\n');
+  const result = [];
+  for (let i = start - 1; i < Math.min(end, lines.length); i++) {
+    result.push(`${(i + 1).toString().padStart(5)}| ${lines[i]}`);
+  }
+  return result.join('\n');
+}
+
+function searchFile(filepath, query) {
+  filepath = path.resolve(filepath);
+  const indexPath = getIndexPath(filepath);
+  
+  if (!fs.existsSync(indexPath)) {
+    return { error: `File not indexed. Run: file_index("${filepath}")` };
+  }
+  
+  const index = JSON.parse(fs.readFileSync(indexPath, 'utf8'));
+  const queryLower = query.toLowerCase();
+  
+  // Search symbols first
+  const symbolMatches = index.symbols.filter(s => 
+    s.name.toLowerCase().includes(queryLower) ||
+    s.sig.toLowerCase().includes(queryLower)
+  ).map(s => ({
+    type: 'symbol',
+    name: s.name,
+    line: s.line,
+    sig: s.sig
+  }));
+  
+  // Search chunks
+  const content = fs.readFileSync(filepath, 'utf8');
+  const lines = content.split('\n');
+  const lineMatches = [];
+  
+  lines.forEach((line, i) => {
+    if (line.toLowerCase().includes(queryLower)) {
+      lineMatches.push({
+        type: 'line',
+        line: i + 1,
+        content: line.trim().slice(0, 100)
+      });
+    }
+  });
+  
+  return {
+    symbols: symbolMatches.slice(0, 10),
+    lines: lineMatches.slice(0, 20)
+  };
+}
+
+function fileSummary(filepath) {
+  filepath = path.resolve(filepath);
+  const indexPath = getIndexPath(filepath);
+  
+  if (!fs.existsSync(indexPath)) {
+    return { error: `File not indexed. Run: file_index("${filepath}")` };
+  }
+  
+  const index = JSON.parse(fs.readFileSync(indexPath, 'utf8'));
+  
+  return {
+    filepath: index.filepath,
+    totalLines: index.totalLines,
+    indexed: index.indexed,
+    functions: index.symbols.filter(s => s.type !== 'class').length,
+    classes: index.symbols.filter(s => s.type === 'class').length,
+    topSymbols: index.symbols.slice(0, 30).map(s => ({
+      name: s.name,
+      type: s.type,
+      line: s.line
+    }))
+  };
+}
+
+// MCP Tool definitions for local file operations
+const FILE_TOOLS = {
+  file_index: {
+    description: "Index a large local file for fast symbol/line lookup. FREE.",
+    schema: {
+      type: "object",
+      properties: { filepath: { type: "string", description: "Path to file" } },
+      required: ["filepath"]
+    },
+    handler: (args) => indexFile(args.filepath)
+  },
+  file_find: {
+    description: "Find where a function/class is defined in indexed files. FREE.",
+    schema: {
+      type: "object", 
+      properties: { 
+        name: { type: "string", description: "Symbol name to find" },
+        filepath: { type: "string", description: "Optional: limit to one file" }
+      },
+      required: ["name"]
+    },
+    handler: (args) => findSymbol(args.name, args.filepath)
+  },
+  file_lines: {
+    description: "Get specific line range from a file with line numbers. FREE.",
+    schema: {
+      type: "object",
+      properties: {
+        filepath: { type: "string" },
+        start: { type: "number", description: "Start line" },
+        end: { type: "number", description: "End line" }
+      },
+      required: ["filepath", "start", "end"]
+    },
+    handler: (args) => getLines(args.filepath, args.start, args.end)
+  },
+  file_search: {
+    description: "Search for content in an indexed file. FREE.",
+    schema: {
+      type: "object",
+      properties: {
+        filepath: { type: "string" },
+        query: { type: "string", description: "Search query" }
+      },
+      required: ["filepath", "query"]
+    },
+    handler: (args) => searchFile(args.filepath, args.query)
+  },
+  file_summary: {
+    description: "Get summary of indexed file (functions, classes, line count). FREE.",
+    schema: {
+      type: "object",
+      properties: { filepath: { type: "string" } },
+      required: ["filepath"]
+    },
+    handler: (args) => fileSummary(args.filepath)
+  }
+};
+
+module.exports = { 
+  FILE_TOOLS, 
+  indexFile, 
+  findSymbol, 
+  getLines, 
+  searchFile, 
+  fileSummary 
+};
+
+// CLI test
+if (require.main === module) {
+  const testFile = process.argv[2] || 'C:\\Users\\Administrator\\Desktop\\50c\\nj-deploy\\api-unified-v8-FINAL-ALL.py';
+  
+  console.log('='.repeat(60));
+  console.log('FILE MEMORY - Node.js Test');
+  console.log('='.repeat(60));
+  
+  console.log('\n[1] Indexing...');
+  console.log(indexFile(testFile));
+  
+  console.log('\n[2] Finding fog_check...');
+  console.log(findSymbol('fog_check'));
+  
+  console.log('\n[3] Lines 2385-2395...');
+  console.log(getLines(testFile, 2385, 2395));
+  
+  console.log('\n[4] Search "beacon"...');
+  const search = searchFile(testFile, 'beacon');
+  console.log('Symbols:', search.symbols?.slice(0, 5));
+  console.log('Lines:', search.lines?.slice(0, 5));
+  
+  console.log('\n[5] Summary...');
+  const sum = fileSummary(testFile);
+  console.log(`${sum.totalLines} lines, ${sum.functions} functions, ${sum.classes} classes`);
+}

package/package.json

@@ -1,40 +1,43 @@
-{
-  "name": "50c",
-  "version": "3.0.7",
-  "description": "50c Hub - One Hub, Many Packs, Infinite Tools. AI developer tools from $0.01-$0.65.",
-  "bin": {
-    "50c": "./bin/50c.js"
-  },
-  "scripts": {
-    "postinstall": "node -e \"console.log('\\n50c Hub installed. Run: 50c install\\n')\""
-  },
-  "keywords": [
-    "mcp",
-    "ai",
-    "llm",
-    "cli",
-    "agent",
-    "50c",
-    "hints",
-    "genius",
-    "beacon",
-    "developer-tools",
-    "context",
-    "compression"
-  ],
-  "author": "genxis",
-  "license": "SEE LICENSE IN LICENSE",
-  "homepage": "https://50c.ai",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/genxis/50c"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "files": [
-    "bin/",
-    "README.md",
-    "LICENSE"
-  ]
-}
+{
+  "name": "50c",
+  "version": "3.0.8",
+  "description": "50c Hub - One Hub, Many Packs, Infinite Tools. AI developer tools from $0.01-$0.65.",
+  "bin": {
+    "50c": "./bin/50c.js"
+  },
+  "scripts": {
+    "postinstall": "node -e \"console.log('\\n50c Hub installed. Run: 50c install\\n')\""
+  },
+  "keywords": [
+    "mcp",
+    "ai",
+    "llm",
+    "cli",
+    "agent",
+    "50c",
+    "hints",
+    "genius",
+    "beacon",
+    "developer-tools",
+    "context",
+    "compression",
+    "caz",
+    "file-memory"
+  ],
+  "author": "genxis",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://50c.ai",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/50c-ai/50c-mcp"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md",
+    "LICENSE"
+  ]
+}