@tarunpahade/asl-parser 1.0.1

package/lib/promptAnalyzer.js

@@ -0,0 +1,358 @@
+const fs = require('fs');
+const path = require('path');
+const { analyzeFile, parseCodebase } = require('./parser');
+
+/**
+ * Extract keywords from a prompt
+ */
+function extractKeywords(prompt) {
+  const lowerPrompt = prompt.toLowerCase();
+  
+  // Common action words
+  const actionWords = ['add', 'create', 'update', 'modify', 'change', 'fix', 'remove', 'delete', 'implement', 'refactor'];
+  
+  // Extract potential function/class names (words that start with capital or camelCase)
+  const nameMatches = prompt.match(/\b([A-Z][a-zA-Z0-9]+|[a-z][a-zA-Z0-9]*[A-Z][a-zA-Z0-9]*)\b/g) || [];
+  
+  // Extract file extensions mentioned
+  const extMatches = prompt.match(/\.(js|ts|jsx|tsx|py|java|cpp|c|h|go|rs|rb|php|swift|kt|vue|svelte|html|css|scss|less|json|yaml|yml|toml|xml)\b/gi) || [];
+  
+  // Extract quoted strings (likely file paths or names)
+  const quotedMatches = prompt.match(/["']([^"']+)["']/g) || [];
+  
+  // Extract file paths (containing / or \)
+  const pathMatches = prompt.match(/[\/\\][\w\-\.\/\\]+/g) || [];
+  
+  // Extract common technical terms
+  const techTerms = [];
+  const techKeywords = ['api', 'endpoint', 'route', 'component', 'function', 'class', 'method', 'variable', 'constant', 'config', 'database', 'db', 'model', 'view', 'controller', 'service', 'util', 'helper', 'handler', 'middleware'];
+  techKeywords.forEach(term => {
+    if (lowerPrompt.includes(term)) techTerms.push(term);
+  });
+  
+  return {
+    actionWords: actionWords.filter(word => lowerPrompt.includes(word)),
+    names: nameMatches,
+    extensions: extMatches.map(ext => ext.toLowerCase()),
+    quoted: quotedMatches.map(q => q.replace(/["']/g, '')),
+    paths: pathMatches,
+    techTerms: techTerms,
+    allKeywords: lowerPrompt.split(/\s+/).filter(word => word.length > 2)
+  };
+}
+
+/**
+ * Score how relevant a file is to the prompt
+ */
+function scoreFileRelevance(fileAnalysis, keywords, prompt) {
+  let score = 0;
+  const lowerPrompt = prompt.toLowerCase();
+  const fileName = fileAnalysis.fileName.toLowerCase();
+  const filePath = fileAnalysis.path.toLowerCase();
+  
+  // Check file name matches
+  keywords.names.forEach(name => {
+    if (fileName.includes(name.toLowerCase()) || filePath.includes(name.toLowerCase())) {
+      score += 10;
+    }
+  });
+  
+  // Check file path matches
+  keywords.paths.forEach(p => {
+    if (filePath.includes(p.toLowerCase())) {
+      score += 15;
+    }
+  });
+  
+  // Check quoted strings (likely file names)
+  keywords.quoted.forEach(q => {
+    if (fileName.includes(q.toLowerCase()) || filePath.includes(q.toLowerCase())) {
+      score += 20;
+    }
+  });
+  
+  // Check extension matches
+  if (keywords.extensions.length > 0 && keywords.extensions.includes(fileAnalysis.extension)) {
+    score += 5;
+  }
+  
+  // Check function/class name matches
+  const allNames = [...fileAnalysis.functions, ...fileAnalysis.classes];
+  keywords.names.forEach(keyword => {
+    allNames.forEach(name => {
+      if (name.toLowerCase().includes(keyword.toLowerCase()) || keyword.toLowerCase().includes(name.toLowerCase())) {
+        score += 8;
+      }
+    });
+  });
+  
+  // Check tech terms in file path
+  keywords.techTerms.forEach(term => {
+    if (filePath.includes(term) || fileName.includes(term)) {
+      score += 5;
+    }
+  });
+  
+  // Check if any keyword appears in the file path
+  keywords.allKeywords.forEach(keyword => {
+    if (filePath.includes(keyword) || fileName.includes(keyword)) {
+      score += 2;
+    }
+  });
+  
+  return score;
+}
+
+/**
+ * Score how relevant a function/class is to the prompt
+ */
+function scoreCodeRelevance(codeName, keywords, prompt) {
+  let score = 0;
+  const lowerName = codeName.toLowerCase();
+  const lowerPrompt = prompt.toLowerCase();
+  
+  // Exact or partial name match
+  keywords.names.forEach(name => {
+    if (lowerName.includes(name.toLowerCase()) || name.toLowerCase().includes(lowerName)) {
+      score += 15;
+    }
+  });
+  
+  // Check if function name contains action words
+  keywords.actionWords.forEach(action => {
+    if (lowerName.includes(action)) {
+      score += 5;
+    }
+  });
+  
+  // Check if prompt mentions the function/class name
+  if (lowerPrompt.includes(lowerName) || lowerName.includes(lowerPrompt.split(/\s+/)[0])) {
+    score += 20;
+  }
+  
+  return score;
+}
+
+/**
+ * Find relevant lines in a file based on keywords
+ */
+function findRelevantLines(filePath, keywords, prompt) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+    const relevantLines = [];
+    
+    lines.forEach((line, index) => {
+      const lowerLine = line.toLowerCase();
+      let lineScore = 0;
+      
+      // Check for keyword matches
+      keywords.names.forEach(name => {
+        if (lowerLine.includes(name.toLowerCase())) {
+          lineScore += 5;
+        }
+      });
+      
+      keywords.actionWords.forEach(action => {
+        if (lowerLine.includes(action)) {
+          lineScore += 3;
+        }
+      });
+      
+      keywords.techTerms.forEach(term => {
+        if (lowerLine.includes(term)) {
+          lineScore += 2;
+        }
+      });
+      
+      // Check for function/class definitions
+      if (line.match(/(function|class|const|let|var)\s+\w+/i)) {
+        lineScore += 10;
+      }
+      
+      if (lineScore > 0) {
+        relevantLines.push({
+          lineNumber: index + 1,
+          content: line.trim(),
+          score: lineScore
+        });
+      }
+    });
+    
+    // Sort by score and return top matches
+    return relevantLines
+      .sort((a, b) => b.score - a.score)
+      .slice(0, 20); // Top 20 most relevant lines
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * Analyze prompt and find impacted code
+ */
+async function analyzePrompt(basePath, userPrompt) {
+  const keywords = extractKeywords(userPrompt);
+  
+  // First, get codebase structure
+  const files = [];
+  const { glob } = require('glob');
+  const CODE_EXTENSIONS = [
+    '.js', '.jsx', '.ts', '.tsx', '.py', '.java', '.cpp', '.c', '.h',
+    '.cs', '.go', '.rs', '.rb', '.php', '.swift', '.kt', '.scala',
+    '.vue', '.svelte', '.html', '.css', '.scss', '.less',
+    '.json', '.yaml', '.yml', '.toml', '.xml'
+  ];
+  
+  const IGNORE_DIRS = [
+    'node_modules', '.git', '.next', '.nuxt', 'dist', 'build',
+    '.cache', 'coverage', '.vscode', '.idea', 'vendor', '__pycache__',
+    '.pytest_cache', 'target', 'bin', 'obj'
+  ];
+  
+  // Find all code files
+  const patterns = CODE_EXTENSIONS.map(ext => `**/*${ext}`);
+  
+  for (const pattern of patterns) {
+    try {
+      const foundFiles = await glob(pattern, {
+        cwd: basePath,
+        absolute: true,
+        ignore: IGNORE_DIRS.map(dir => `**/${dir}/**`)
+      });
+      
+      for (const filePath of foundFiles) {
+        const relativePath = path.relative(basePath, filePath);
+        const parts = relativePath.split(path.sep);
+        
+        // Skip ignored directories
+        if (parts.some(part => IGNORE_DIRS.includes(part) || part.startsWith('.'))) {
+          continue;
+        }
+        
+        files.push(filePath);
+      }
+    } catch (error) {
+      // Continue on error
+    }
+  }
+  
+  // Analyze each file
+  const fileScores = [];
+  for (const filePath of files) {
+    const analysis = analyzeFile(filePath);
+    if (analysis.error) continue;
+    
+    const fileScore = scoreFileRelevance(analysis, keywords, userPrompt);
+    
+    if (fileScore > 0) {
+      // Score functions and classes
+      const relevantFunctions = analysis.functions
+        .map(func => ({
+          name: func,
+          score: scoreCodeRelevance(func, keywords, userPrompt),
+          type: 'function'
+        }))
+        .filter(item => item.score > 0)
+        .sort((a, b) => b.score - a.score);
+      
+      const relevantClasses = analysis.classes
+        .map(cls => ({
+          name: cls,
+          score: scoreCodeRelevance(cls, keywords, userPrompt),
+          type: 'class'
+        }))
+        .filter(item => item.score > 0)
+        .sort((a, b) => b.score - a.score);
+      
+      // Find relevant lines
+      const relevantLines = findRelevantLines(filePath, keywords, userPrompt);
+      
+      fileScores.push({
+        file: analysis,
+        score: fileScore,
+        relevantFunctions,
+        relevantClasses,
+        relevantLines: relevantLines.slice(0, 10) // Top 10 lines
+      });
+    }
+  }
+  
+  // Sort by score and return top matches
+  return fileScores
+    .sort((a, b) => b.score - a.score)
+    .slice(0, 20); // Top 20 most relevant files
+}
+
+/**
+ * Generate impact report
+ */
+function generateImpactReport(results, prompt) {
+  let report = `# Impact Analysis Report\n\n`;
+  report += `**Prompt:** "${prompt}"\n\n`;
+  report += `**Generated:** ${new Date().toISOString()}\n\n`;
+  report += `---\n\n`;
+  
+  if (results.length === 0) {
+    report += `## No Matches Found\n\n`;
+    report += `No files, functions, or code sections were found matching your prompt.\n`;
+    report += `Try using more specific keywords like function names, file paths, or technical terms.\n\n`;
+    return report;
+  }
+  
+  report += `## Summary\n\n`;
+  report += `- **Files Affected:** ${results.length}\n`;
+  const totalFunctions = results.reduce((sum, r) => sum + r.relevantFunctions.length, 0);
+  const totalClasses = results.reduce((sum, r) => sum + r.relevantClasses.length, 0);
+  report += `- **Functions Impacted:** ${totalFunctions}\n`;
+  report += `- **Classes Impacted:** ${totalClasses}\n\n`;
+  
+  report += `---\n\n`;
+  report += `## Detailed Impact Analysis\n\n`;
+  
+  results.forEach((result, index) => {
+    const file = result.file;
+    report += `### ${index + 1}. \`${file.path}\`\n\n`;
+    report += `**Relevance Score:** ${result.score}\n\n`;
+    report += `- **Extension:** ${file.extension || '(none)'}\n`;
+    report += `- **Total Lines:** ${file.totalLines}\n`;
+    report += `- **Size:** ${(file.size / 1024).toFixed(2)} KB\n\n`;
+    
+    if (result.relevantFunctions.length > 0) {
+      report += `#### Functions Impacted:\n\n`;
+      result.relevantFunctions.forEach(func => {
+        report += `- **${func.name}** (score: ${func.score})\n`;
+      });
+      report += `\n`;
+    }
+    
+    if (result.relevantClasses.length > 0) {
+      report += `#### Classes Impacted:\n\n`;
+      result.relevantClasses.forEach(cls => {
+        report += `- **${cls.name}** (score: ${cls.score})\n`;
+      });
+      report += `\n`;
+    }
+    
+    if (result.relevantLines.length > 0) {
+      report += `#### Relevant Lines:\n\n`;
+      report += `\`\`\`\n`;
+      result.relevantLines.forEach(line => {
+        report += `${line.lineNumber}: ${line.content}\n`;
+      });
+      report += `\`\`\`\n\n`;
+    }
+    
+    report += `---\n\n`;
+  });
+  
+  report += `## Recommendations\n\n`;
+  report += `1. **Review the top-scoring files first** - They are most likely to be affected by your changes\n`;
+  report += `2. **Check function/class dependencies** - Functions and classes listed may need updates\n`;
+  report += `3. **Examine relevant lines** - The specific lines shown may require modifications\n`;
+  report += `4. **Consider related files** - Files in the same directory or with similar names may also be impacted\n\n`;
+  
+  return report;
+}
+
+module.exports = { analyzePrompt, generateImpactReport, extractKeywords };

package/lib/rag/minimal-rag.js

@@ -0,0 +1,170 @@
+// src/rag/minimal-rag.js
+// Drop-in RAG module for asl-parser
+// Usage: asl rag "your query"
+
+const fs = require('fs');
+const path = require('path');
+
+class MinimalRAG {
+  constructor(codebasePath = './') {
+    this.codebasePath = codebasePath;
+    this.chunks = [];
+    this.initialized = false;
+  }
+
+  /**
+   * Index all code files in the codebase
+   */
+  async initialize(files) {
+    console.log('📚 Indexing codebase...');
+    
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(file, 'utf-8');
+        this.indexFile(file, content);
+      } catch (err) {
+        // Skip unreadable files
+      }
+    }
+
+    this.initialized = true;
+    console.log(`✅ Indexed ${this.chunks.length} code sections\n`);
+  }
+
+  /**
+   * Break a file into searchable chunks
+   */
+  indexFile(filepath, content) {
+    const lines = content.split('\n');
+    const chunkSize = 20; // Lines per chunk
+    const overlap = 5;
+
+    // Create function/class aware chunks
+    for (let i = 0; i < lines.length; i += chunkSize - overlap) {
+      const chunk = lines.slice(i, i + chunkSize).join('\n');
+      
+      if (chunk.trim().length > 0) {
+        this.chunks.push({
+          file: filepath,
+          lineStart: i + 1,
+          lineEnd: Math.min(i + chunkSize, lines.length),
+          content: chunk,
+          context: this.extractContext(chunk, filepath)
+        });
+      }
+    }
+  }
+
+  /**
+   * Extract context (functions, classes, comments)
+   */
+  extractContext(chunk, filepath) {
+    const contexts = [];
+
+    // Find function names
+    const funcMatch = chunk.match(/(?:function|const|async)\s+(\w+)\s*(?:=|:|\()/g);
+    if (funcMatch) contexts.push(...funcMatch.map(f => f.split(/\s+/)[1]));
+
+    // Find class names
+    const classMatch = chunk.match(/class\s+(\w+)/g);
+    if (classMatch) contexts.push(...classMatch.map(c => c.split(/\s+/)[1]));
+
+    // Get file path parts for context
+    contexts.push(...filepath.split('/').filter(p => p.length > 2));
+
+    return contexts.filter(Boolean);
+  }
+
+  /**
+   * Search for relevant code sections
+   */
+  search(query, topK = 8) {
+    if (!this.initialized) {
+      throw new Error('RAG not initialized. Call initialize() first.');
+    }
+
+    const queryTokens = query.toLowerCase().split(/\s+/);
+    const results = [];
+
+    for (const chunk of this.chunks) {
+      let score = 0;
+      const chunkText = chunk.content.toLowerCase();
+      const chunkContext = chunk.context.map(c => c.toLowerCase());
+
+      // Token matching in content (higher weight for exact matches)
+      for (const token of queryTokens) {
+        const contentMatches = (chunkText.match(new RegExp(`\\b${token}\\w*`, 'g')) || []).length;
+        score += contentMatches * 2;
+
+        // Context matching (lower weight)
+        const contextMatches = chunkContext.filter(c => c.includes(token)).length;
+        score += contextMatches;
+      }
+
+      // Relevance boost for file path
+      if (queryTokens.some(t => chunk.file.toLowerCase().includes(t))) {
+        score += 3;
+      }
+
+      if (score > 0) {
+        results.push({ ...chunk, score });
+      }
+    }
+
+    return results
+      .sort((a, b) => b.score - a.score)
+      .slice(0, topK);
+  }
+
+  /**
+   * Format results for display
+   */
+  formatResults(results, query) {
+    if (results.length === 0) {
+      return `❌ No relevant code found for: "${query}"`;
+    }
+
+    let output = `✅ Found ${results.length} relevant sections:\n`;
+    output += `📍 Query: "${query}"\n`;
+    output += '─'.repeat(70) + '\n\n';
+
+    results.forEach((result, idx) => {
+      const relevance = Math.min(100, Math.round((result.score / 10) * 10));
+      const fileIcon = this.getFileIcon(result.file);
+      
+      output += `${idx + 1}. ${fileIcon} ${result.file}\n`;
+      output += `   📌 Lines ${result.lineStart}-${result.lineEnd} | `;
+      output += `📊 Relevance: ${relevance}%\n`;
+      
+      if (result.context.length > 0) {
+        output += `   🎯 Context: ${result.context.slice(0, 3).join(', ')}\n`;
+      }
+
+      // Show code snippet
+      const snippet = result.content
+        .split('\n')
+        .slice(0, 3)
+        .join('\n')
+        .substring(0, 80);
+      
+      output += `   > ${snippet}...\n`;
+      output += '\n';
+    });
+
+    return output;
+  }
+
+  getFileIcon(filepath) {
+    if (filepath.includes('.js')) return '📄';
+    if (filepath.includes('.ts')) return '📘';
+    if (filepath.includes('.py')) return '🐍';
+    if (filepath.includes('.json')) return '📋';
+    if (filepath.includes('test')) return '🧪';
+    if (filepath.includes('auth')) return '🔐';
+    if (filepath.includes('api')) return '🌐';
+    if (filepath.includes('db')) return '🗄️';
+    return '📑';
+  }
+}
+
+module.exports = MinimalRAG;

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@tarunpahade/asl-parser",
+  "version": "1.0.1",
+  "description": "A CLI tool to parse and analyze codebases, generating agent specifications in agents.md",
+  "main": "index.js",
+  "bin": {
+    "asl": "./bin/asl.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "asl",
+    "parser",
+    "codebase",
+    "analysis",
+    "agents",
+    "cli",
+    "code-analysis",
+    "documentation",
+    "markdown"
+  ],
+  "author": "tpahade10",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tpahade10/asl-parser.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tpahade10/asl-parser/issues"
+  },
+  "homepage": "https://github.com/tpahade10/asl-parser#readme",
+  "dependencies": {
+    "@tarunpahade/asl-parser": "^1.0.1",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "glob": "^10.3.10"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}