@redigg/redigg 0.1.0

package/skills/system/code-analysis/index.ts

@@ -0,0 +1,180 @@
+import { Skill, SkillContext, SkillParams, SkillResult } from '../../../src/skills/types.js';
+import fs from 'fs/promises';
+import path from 'path';
+
+export default class CodeAnalysisSkill implements Skill {
+  id = 'code_analysis';
+  name = 'Code Analysis';
+  description = 'Analyze project structure, scan codebase stats, and summarize code files';
+  tags = ['code', 'analysis', 'summary', 'scan'];
+
+  async execute(ctx: SkillContext, params: SkillParams): Promise<SkillResult> {
+    const targetPath = params.path || '.';
+    const operation = params.operation || 'scan'; // Default to scan
+    const safePath = path.resolve(process.cwd(), targetPath);
+
+    ctx.log('thinking', `Analyzing code at ${safePath} (operation: ${operation})`);
+
+    try {
+      if (operation === 'structure') {
+        const structure = await this.getProjectStructure(safePath);
+        return { structure };
+      } else if (operation === 'summarize') {
+        const summary = await this.summarizeCode(ctx, safePath);
+        return { summary };
+      } else if (operation === 'scan') {
+        const scan = await this.scanCodebase(safePath);
+        return { scan };
+      } else {
+        throw new Error(`Unknown operation: ${operation}`);
+      }
+    } catch (error) {
+      ctx.log('error', `Code analysis failed: ${error}`);
+      throw error;
+    }
+  }
+
+  private async getProjectStructure(dir: string, depth = 0, maxDepth = 4): Promise<string> {
+    if (depth > maxDepth) return ''; 
+    
+    let output = '';
+    try {
+      const files = await fs.readdir(dir);
+      // Sort: directories first, then files
+      const entries = await Promise.all(files.map(async file => {
+          const filePath = path.join(dir, file);
+          const stat = await fs.stat(filePath).catch(() => null);
+          return { file, stat };
+      }));
+      
+      const validEntries = entries.filter(e => e.stat && !e.file.startsWith('.') && e.file !== 'node_modules' && e.file !== 'dist' && e.file !== 'build' && e.file !== '.git');
+      
+      validEntries.sort((a, b) => {
+          if (a.stat!.isDirectory() && !b.stat!.isDirectory()) return -1;
+          if (!a.stat!.isDirectory() && b.stat!.isDirectory()) return 1;
+          return a.file.localeCompare(b.file);
+      });
+
+      for (const { file, stat } of validEntries) {
+        const indent = '  '.repeat(depth);
+        if (stat!.isDirectory()) {
+          output += `${indent}- ${file}/\n`;
+          output += await this.getProjectStructure(path.join(dir, file), depth + 1, maxDepth);
+        } else {
+          output += `${indent}- ${file}\n`;
+        }
+      }
+    } catch (e) {
+      // Ignore errors
+    }
+    return output;
+  }
+
+  private async scanCodebase(dir: string): Promise<any> {
+      const stats = {
+          files: 0,
+          directories: 0,
+          totalSize: 0,
+          extensions: {} as Record<string, number>,
+          sloc: 0,
+          keyFiles: [] as string[]
+      };
+
+      await this.traverse(dir, stats);
+      
+      // Format extensions for display
+      const extSummary = Object.entries(stats.extensions)
+          .sort(([,a], [,b]) => b - a)
+          .slice(0, 10)
+          .map(([ext, count]) => `${ext}: ${count}`)
+          .join(', ');
+
+      const summary = `
+**Codebase Scan Results**
+- **Total Files:** ${stats.files}
+- **Directories:** ${stats.directories}
+- **Total Size:** ${(stats.totalSize / 1024 / 1024).toFixed(2)} MB
+- **Total SLOC:** ${stats.sloc}
+- **Key Files:** ${stats.keyFiles.join(', ')}
+- **Extensions:** ${extSummary}
+      `.trim();
+
+      return { stats, summary };
+  }
+
+  private async traverse(dir: string, stats: any, depth = 0) {
+      if (depth > 10) return;
+      
+      try {
+          const files = await fs.readdir(dir);
+          for (const file of files) {
+              if (file.startsWith('.') || file === 'node_modules' || file === 'dist' || file === 'build' || file === 'coverage') continue;
+              
+              const filePath = path.join(dir, file);
+              const stat = await fs.stat(filePath);
+              
+              if (stat.isDirectory()) {
+                  stats.directories++;
+                  await this.traverse(filePath, stats, depth + 1);
+              } else {
+                  stats.files++;
+                  stats.totalSize += stat.size;
+                  const ext = path.extname(file);
+                  if (ext) {
+                    stats.extensions[ext] = (stats.extensions[ext] || 0) + 1;
+                  }
+                  
+                  if (['.ts', '.tsx', '.js', '.jsx', '.css', '.scss', '.html', '.md', '.json', '.py', '.go', '.rs'].includes(ext)) {
+                      // Only count SLOC for text files
+                      const content = await fs.readFile(filePath, 'utf-8');
+                      stats.sloc += content.split('\n').filter(l => l.trim().length > 0).length;
+                  }
+
+                  if (['package.json', 'tsconfig.json', 'README.md', 'Dockerfile', 'docker-compose.yml', 'Makefile', 'Cargo.toml', 'go.mod'].includes(file)) {
+                      stats.keyFiles.push(path.relative(process.cwd(), filePath));
+                  }
+              }
+          }
+      } catch (e) {
+          // ignore
+      }
+  }
+
+  private async summarizeCode(ctx: SkillContext, filePath: string): Promise<string> {
+    try {
+      const stat = await fs.stat(filePath);
+      if (stat.isDirectory()) {
+          // Summarize directory: list files and maybe read README
+          const files = await fs.readdir(filePath);
+          const visibleFiles = files.filter(f => !f.startsWith('.'));
+          let summary = `Directory: ${path.basename(filePath)}\nFiles: ${visibleFiles.join(', ')}\n`;
+          
+          if (visibleFiles.includes('README.md')) {
+              const readme = await fs.readFile(path.join(filePath, 'README.md'), 'utf-8');
+              summary += `\nREADME Preview:\n${readme.slice(0, 200)}...\n`;
+          }
+          return summary;
+      } else {
+          // Summarize file
+          const content = await fs.readFile(filePath, 'utf-8');
+          const lines = content.split('\n');
+          const sloc = lines.filter(l => l.trim().length > 0).length;
+          
+          if (sloc > 500) {
+              return `File: ${path.basename(filePath)}\nSLOC: ${sloc}\n(File too large for full summary)`;
+          }
+
+          // Use LLM to summarize
+          const prompt = `Summarize this code file in 1-2 sentences:\n\n${content}`;
+          try {
+             const response = await ctx.llm.chat([{ role: 'user', content: prompt }]);
+             return `File: ${path.basename(filePath)}\nSLOC: ${sloc}\nSummary: ${response.content}`;
+          } catch (e) {
+             return `File: ${path.basename(filePath)}\nSLOC: ${sloc}\n(LLM summary failed)`;
+          }
+      }
+    } catch (e) {
+      return `Failed to summarize ${filePath}`;
+    }
+  }
+}

package/skills/system/local-file-ops/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: local-file-ops
+description: List, read, organize, and search local research files
+tags: [system, file, local]
+---
+
+# Local File Operations
+
+This skill allows the agent to interact with the local filesystem.
+
+## Instructions
+
+Use this skill to:
+- Explore the file system
+- Read file contents
+- Organize files (e.g. moving PDFs)
+- Search for files by name
+
+## Actions
+
+### list
+List files in a directory.
+
+**Parameters:**
+- `path`: Directory path (default: current)
+- `recursive`: Boolean, whether to list recursively
+
+### read
+Read the content of a file.
+
+**Parameters:**
+- `path`: File path
+
+### write
+Write content to a file.
+
+**Parameters:**
+- `path`: File path
+- `content`: Content string
+
+### search
+Find files matching a pattern.
+
+**Parameters:**
+- `pattern`: Search string (filename substring)
+- `path`: Root directory
+
+### organize
+Organize files based on rules (currently specialized for PDFs).
+
+**Parameters:**
+- `operation`: 'organize'
+
+## Security
+Operations are restricted to the current workspace.

package/skills/system/local-file-ops/index.ts

@@ -0,0 +1,123 @@
+import { Skill, SkillContext, SkillParams, SkillResult } from '../../../src/skills/types.js';
+import fs from 'fs/promises';
+import path from 'path';
+
+export default class LocalFileSkill implements Skill {
+  id = 'local_file_ops';
+  name = 'Local File Operations';
+  description = 'List, read, organize, and search local research files';
+  tags = ['system', 'file', 'local'];
+
+  async execute(ctx: SkillContext, params: SkillParams): Promise<SkillResult> {
+    const operation = params.operation as 'list' | 'read' | 'write' | 'organize' | 'search';
+    const targetPath = params.path || '.';
+    const recursive = params.recursive === true;
+    
+    // Security check: ensure path is within workspace or allowed dirs
+    const safePath = path.resolve(process.cwd(), targetPath); // Default to CWD for now
+    
+    ctx.log('thinking', `Performing ${operation} on ${safePath} (recursive: ${recursive})`);
+
+    try {
+      switch (operation) {
+        case 'list':
+          if (recursive) {
+            const files = await this.listRecursive(safePath);
+            ctx.log('tool_result', `Found ${files.length} files recursively`);
+            return { files };
+          } else {
+            const files = await fs.readdir(safePath);
+            ctx.log('tool_result', `Found ${files.length} files`);
+            return { files };
+          }
+        
+        case 'read':
+          try {
+            const stat = await fs.stat(safePath);
+            if (stat.isDirectory()) {
+               throw new Error('Path is a directory, not a file');
+            }
+            const content = await fs.readFile(safePath, 'utf-8');
+            ctx.log('tool_result', `Read ${content.length} characters`);
+            return { content, path: safePath };
+          } catch (err) {
+            ctx.log('error', `Failed to read file: ${err}`);
+            throw err;
+          }
+
+        case 'write':
+          if (!params.content) throw new Error('Content required for write');
+          await fs.writeFile(safePath, params.content, 'utf-8');
+          ctx.log('action', `Wrote to file ${safePath}`);
+          return { success: true, path: safePath };
+
+        case 'search':
+          const pattern = params.pattern as string;
+          if (!pattern) throw new Error('Pattern required for search');
+          
+          const allFiles = await this.listRecursive(safePath);
+          const matchedFiles = allFiles.filter(f => f.includes(pattern));
+          
+          ctx.log('tool_result', `Found ${matchedFiles.length} files matching "${pattern}"`);
+          return { files: matchedFiles };
+
+        case 'organize':
+          // Example: Move PDFs to a 'papers' folder
+          ctx.log('action', 'Organizing PDF files...');
+          
+          let fileList: string[] = [];
+          try {
+             fileList = await fs.readdir(safePath);
+          } catch (e) {
+             ctx.log('error', `Failed to read dir ${safePath}: ${e}`);
+             return { moved: 0 };
+          }
+
+          const pdfs = fileList.filter(f => f.toLowerCase().endsWith('.pdf'));
+          
+          if (pdfs.length === 0) {
+            return { moved: 0, destination: safePath };
+          }
+
+          const papersDir = path.join(safePath, 'papers');
+          await fs.mkdir(papersDir, { recursive: true });
+          
+          for (const pdf of pdfs) {
+            await fs.rename(path.join(safePath, pdf), path.join(papersDir, pdf));
+          }
+          
+          ctx.log('tool_result', `Moved ${pdfs.length} PDFs to ${papersDir}`);
+          return { moved: pdfs.length, destination: papersDir };
+
+        default:
+          throw new Error(`Unknown operation: ${operation}`);
+      }
+    } catch (error) {
+      ctx.log('error', `File operation failed: ${error}`);
+      throw error;
+    }
+  }
+
+  private async listRecursive(dir: string): Promise<string[]> {
+    let results: string[] = [];
+    try {
+        const list = await fs.readdir(dir);
+        for (const file of list) {
+            if (file.startsWith('.') || file === 'node_modules') continue;
+            
+            const filePath = path.resolve(dir, file);
+            const stat = await fs.stat(filePath);
+            
+            if (stat && stat.isDirectory()) {
+                const res = await this.listRecursive(filePath);
+                results = results.concat(res);
+            } else {
+                results.push(filePath);
+            }
+        }
+    } catch (err) {
+        // Ignore permission errors or missing dirs during recursion
+    }
+    return results;
+  }
+}

package/skills/vendor/PACK.md

@@ -0,0 +1,11 @@
+# Vendor Skills Pack
+
+Third-party or specialized domain skills.
+
+## Skills
+
+- `literature-review`: Literature review and academic search
+- `agent-browser`: Web browsing capabilities
+- `searxng`: Meta-search engine integration
+- `proactive-agent`: Autonomous behavior modules
+- `self-improving-agent`: Learning mechanisms

package/skills/vendor/agent-browser/.clawhub/origin.json

@@ -0,0 +1,7 @@
+{
+  "version": 1,
+  "registry": "https://clawhub.ai",
+  "slug": "agent-browser",
+  "installedVersion": "0.2.0",
+  "installedAt": 1772701268218
+}

package/skills/vendor/agent-browser/CONTRIBUTING.md

@@ -0,0 +1,63 @@
+# Contributing to Agent Browser Skill
+
+This skill wraps the agent-browser CLI. Determine where the problem lies before reporting issues.
+
+## Issue Reporting Guide
+
+### Open an issue in this repository if
+
+- The skill documentation is unclear or missing
+- Examples in SKILL.md do not work
+- You need help using the CLI with this skill wrapper
+- The skill is missing a command or feature
+
+### Open an issue at the agent-browser repository if
+
+- The CLI crashes or throws errors
+- Commands do not behave as documented
+- You found a bug in the browser automation
+- You need a new feature in the CLI
+
+## Before Opening an Issue
+
+1. Install the latest version
+   ```bash
+   npm install -g agent-browser@latest
+   ```
+
+2. Test the command in your terminal to isolate the issue
+
+## Issue Report Template
+
+Use this template to provide necessary information.
+
+```markdown
+### Description
+[Provide a clear and concise description of the bug]
+
+### Reproduction Steps
+1. [First Step]
+2. [Second Step]
+3. [Observe error]
+
+### Expected Behavior
+[Describe what you expected to happen]
+
+### Environment Details
+- **Skill Version:** [e.g. 1.0.2]
+- **agent-browser Version:** [output of agent-browser --version]
+- **Node.js Version:** [output of node -v]
+- **Operating System:** [e.g. macOS Sonoma, Windows 11, Ubuntu 22.04]
+
+### Additional Context
+- [Full error output or stack trace]
+- [Screenshots]
+- [Website URLs where the failure occurred]
+```
+
+## Adding New Commands to the Skill
+
+Update SKILL.md when the upstream CLI adds new commands.
+- Keep the Installation section
+- Add new commands in the correct category
+- Include usage examples