create-snowline-agents 1.0.0

package/smart_replace/replace_text.py

@@ -0,0 +1,113 @@
+import os
+import sys
+import argparse
+import re
+import shutil
+from datetime import datetime
+
+# Force UTF-8 encoding for Windows terminal
+if sys.stdout.encoding.lower() != 'utf-8':
+    sys.stdout.reconfigure(encoding='utf-8')
+
+DEFAULT_EXCLUDES = {'.git', 'node_modules', '.history', 'vendor', 'dist', 'build', 'quarantine', '.backup_replace', '.agents'}
+MAX_FILE_SIZE = 500 * 1024 # 500 KB
+
+def find_project_root(start_path):
+    current = os.path.abspath(start_path)
+    while True:
+        if os.path.exists(os.path.join(current, 'package.json')) or os.path.exists(os.path.join(current, '.git')):
+            return current
+        parent = os.path.dirname(current)
+        if parent == current:
+            return os.path.abspath(start_path)
+        current = parent
+
+def get_args():
+    parser = argparse.ArgumentParser(description="Smart Replace (Pure Python Edition)")
+    parser.add_argument("target_dir", help="Target directory (absolute path)")
+    parser.add_argument("search_string", help="String or pattern to search for")
+    parser.add_argument("replace_string", help="String to replace with")
+    parser.add_argument("--ext", help="Comma-separated extensions to include (e.g. .js,.jsx)", default="")
+    parser.add_argument("--regex", action="store_true", help="Treat search_string as a regular expression")
+    parser.add_argument("--whole-word", action="store_true", help="Match whole words only")
+    parser.add_argument("--apply", action="store_true", help="Actually modify the files")
+    return parser.parse_args()
+
+def backup_file(filepath, backup_dir):
+    rel_path = os.path.relpath(filepath, os.getcwd())
+    backup_path = os.path.join(backup_dir, rel_path)
+    os.makedirs(os.path.dirname(backup_path), exist_ok=True)
+    shutil.copy2(filepath, backup_path)
+    return backup_path
+
+def main():
+    args = get_args()
+    
+    if not os.path.exists(args.target_dir):
+        print(f"[FAIL] Target directory not found: {args.target_dir}")
+        sys.exit(1)
+        
+    exts = [e.strip() for e in args.ext.split(',')] if args.ext else []
+    
+    pattern_str = args.search_string
+    if not args.regex:
+        pattern_str = re.escape(pattern_str)
+    if args.whole_word:
+        pattern_str = r'\b' + pattern_str + r'\b'
+        
+    try:
+        regex = re.compile(pattern_str)
+    except re.error as e:
+        print(f"[FAIL] Invalid regex: {e}")
+        sys.exit(1)
+        
+    backup_dir = None
+    if args.apply:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        project_root = find_project_root(args.target_dir)
+        backup_dir = os.path.join(project_root, '.backup_replace', timestamp)
+
+    match_count = 0
+    file_count = 0
+    scanned_files = 0
+    
+    for root, dirs, files in os.walk(args.target_dir):
+        dirs[:] = [d for d in dirs if d not in DEFAULT_EXCLUDES]
+        for file in files:
+            if exts and not any(file.endswith(e) for e in exts):
+                continue
+            
+            filepath = os.path.join(root, file)
+            if os.path.getsize(filepath) > MAX_FILE_SIZE:
+                continue
+                
+            scanned_files += 1
+            
+            try:
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    content = f.read()
+            except UnicodeDecodeError:
+                continue
+                
+            if regex.search(content):
+                file_count += 1
+                new_content, count = regex.subn(args.replace_string, content)
+                match_count += count
+                
+                rel_path = os.path.relpath(filepath, args.target_dir)
+                print(f"[WARN] Found {count} matches in {rel_path}")
+                
+                if args.apply:
+                    backup_file(filepath, backup_dir)
+                    with open(filepath, 'w', encoding='utf-8') as f:
+                        f.write(new_content)
+
+    print(f"\n[OK] Scan selesai ({scanned_files} file dipindai). Menemukan {match_count} kecocokan di {file_count} file.")
+    if not args.apply:
+        print("\n💡 PROMPT UNTUK AI (Copy-Paste ini):")
+        print('"Berdasarkan hasil dry-run di atas, tolong jalankan ulang perintah tersebut dengan menambahkan flag --apply untuk menerapkan perubahannya secara aman."')
+    else:
+        print(f"\n[INFO] Perubahan telah diterapkan ke {file_count} file. Backup tersimpan di: {backup_dir}")
+
+if __name__ == "__main__":
+    main()

package/smart_search/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: Smart Code Reference Finder
+description: Use this skill when the user asks you to find WHERE a specific function, component, class, or variable is used across a project. This skill uses a Python script to extract the code blocks surrounding the keyword, providing you with full context (e.g. what props are passed, what variables surround it) instead of just single raw lines like standard grep.
+---
+
+## Instructions for AI Agent
+
+When analyzing a codebase to find references, standard `grep_search` is often insufficient because it only returns the exact line containing the keyword, omitting critical surrounding logic. 
+
+**When to use this skill:**
+- The user asks to find where a component/function is used.
+- You need to know *how* a specific function is invoked across multiple files (what props/arguments are passed).
+- You are refactoring a core module and need to see all its dependent implementations in context.
+
+**How to use:**
+**Command to run:**
+```powershell
+python .agents/skills/smart_search/code_finder.py "<absolute_target_directory>" "<keyword>" --ext "<optional_extensions>"
+```
+
+**Parameters:**
+- `<absolute_target_directory>`: The absolute path to the directory you want to scan (e.g., `/path/to/your/src`).
+- `<keyword>`: The exact code string to search for (e.g., `MyComponent`).
+- `--ext`: (Optional) Comma-separated file extensions to limit the search (e.g., `.jsx,.js,.php`).
+
+**Expected Output:**
+The script will output beautifully formatted Markdown text directly into standard output. It groups results by file and shows blocks of code (with 5 lines of context above and below the match). The exact line containing the match will be highlighted with a `>` arrow. Read this output carefully to understand the implementation context before deciding on your next coding action.

package/smart_search/code_finder.py

@@ -0,0 +1,103 @@
+import os
+import sys
+import argparse
+
+if sys.stdout.encoding != 'utf-8':
+    sys.stdout.reconfigure(encoding='utf-8')
+
+MAX_FILE_SIZE = 500 * 1024 # 500 KB
+DEFAULT_EXCLUDES = {'node_modules', '.git', 'vendor', 'build', 'dist', '.idea', '.vscode', '.history', '.backup_replace', '.agents'}
+
+def search_files(directory, keyword, extensions):
+    results = []
+    scanned = 0
+    skipped = 0
+    
+    for root, dirs, files in os.walk(directory):
+        dirs[:] = [d for d in dirs if d not in DEFAULT_EXCLUDES]
+            
+        for file in files:
+            if extensions and not any(file.endswith(ext) for ext in extensions):
+                continue
+                
+            filepath = os.path.join(root, file)
+            if os.path.getsize(filepath) > MAX_FILE_SIZE:
+                skipped += 1
+                continue
+                
+            scanned += 1
+            try:
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    lines = f.readlines()
+            except Exception:
+                continue
+                
+            matches = []
+            for i, line in enumerate(lines):
+                if keyword in line:
+                    matches.append(i)
+                    
+            if matches:
+                context_lines = 5
+                blocks = []
+                current_block = None
+                
+                for m in matches:
+                    start = max(0, m - context_lines)
+                    end = min(len(lines), m + context_lines + 1)
+                    
+                    if current_block and start <= current_block['end']:
+                        current_block['end'] = max(current_block['end'], end)
+                        current_block['matches'].append(m)
+                    else:
+                        if current_block:
+                            blocks.append(current_block)
+                        current_block = {'start': start, 'end': end, 'matches': [m]}
+                
+                if current_block:
+                    blocks.append(current_block)
+                    
+                results.append({'file': filepath, 'blocks': blocks, 'lines': lines})
+                
+    return results, scanned, skipped
+
+def main():
+    parser = argparse.ArgumentParser(description="Smart Code Finder - Find code with context (Token Efficient)")
+    parser.add_argument("target_dir", help="Directory to scan")
+    parser.add_argument("keyword", help="Search keyword (e.g., 'function_name')")
+    parser.add_argument("--ext", help="Comma-separated extensions to filter (e.g., .js,.jsx)", default="")
+    args = parser.parse_args()
+
+    extensions = [ext.strip() for ext in args.ext.split(",")] if args.ext else []
+    
+    results, scanned, skipped = search_files(args.target_dir, args.keyword, extensions)
+    
+    if not results:
+        print(f"[OK] Keyword '{args.keyword}' not found in {scanned} files.")
+        sys.exit(0)
+        
+    print(f"🔎 SEARCH RESULTS: '{args.keyword}'")
+    print("=" * 60)
+    
+    total_matches = 0
+    for r in results:
+        rel_path = os.path.relpath(r['file'], args.target_dir)
+        print(f"\n[WARN] Found in: {rel_path}")
+        print("-" * 60)
+        
+        for block in r['blocks']:
+            for i in range(block['start'], block['end']):
+                line_str = r['lines'][i].rstrip()
+                prefix = ">>" if i in block['matches'] else "  "
+                print(f"{i+1:5d} | {prefix} {line_str}")
+                if i in block['matches']:
+                    total_matches += 1
+            print("-" * 30)
+
+    print("\n" + "=" * 60)
+    print(f"[OK] Selesai: {total_matches} kecocokan di {len(results)} file (dari {scanned} dipindai, {skipped} dilewati karena >500KB).")
+    print("\n💡 PROMPT UNTUK AI (Copy-Paste ini):")
+    print('"Tolong baca cuplikan kode di atas. Jika Anda perlu mengubah kode tersebut, gunakan tool replace_file_content pada file yang disebutkan di atas."')
+
+if __name__ == "__main__":
+    main()

package/smart_tree/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: Smart Directory Mapper (Tree Viewer)
+description: Use this skill when you need to understand the project structure, locate files, or map out a directory tree WITHOUT consuming a huge amount of tokens. This script generates a compact, `.gitignore`-aware visual tree of a directory, making it vastly superior to the default `list_dir` tool which returns verbose JSON output.
+---
+
+# Smart Directory Mapper (Tree Viewer)
+
+When exploring a new project or trying to locate where certain feature files might be stored, DO NOT use the default `list_dir` tool on large folders, as it will flood your context window with raw JSON and token-heavy metadata.
+
+Instead, ALWAYS use this `smart_tree` tool.
+
+## Usage
+Run the script using Python. You can provide an optional `max_depth` argument to control how deep the tree goes (default is 3).
+
+```bash
+python .agents/skills/smart_tree/scripts/tree_viewer.py <directory_path> [max_depth]
+```
+
+### Examples:
+Map the entire project root up to 2 levels deep:
+```bash
+python .agents/skills/smart_tree/scripts/tree_viewer.py . 2
+```
+
+Map a specific component folder up to 5 levels deep:
+```bash
+python .agents/skills/smart_tree/scripts/tree_viewer.py src/view/admin 5
+```
+
+## Advantages
+1. **Token Efficient**: Outputs a clean visual hierarchy (`├──`, `└──`) instead of raw JSON.
+2. **Noise Reduction**: Automatically parses `.gitignore` and hard-ignores junk directories (`node_modules`, `vendor`, `.git`, `.agents`, `dist`) so you don't get overwhelmed with irrelevant files.
+3. **Controlled Depth**: The `max_depth` parameter prevents you from accidentally reading an infinitely deep directory structure.

package/smart_tree/scripts/tree_viewer.py

@@ -0,0 +1,72 @@
+import os
+import sys
+import fnmatch
+
+def parse_gitignore(dir_path):
+    ignore_patterns = [
+        '.git', '.agents', 'node_modules', 'vendor', '__pycache__', 
+        '.DS_Store', 'dist', 'build', '.idea', '.vscode'
+    ]
+    gitignore_path = os.path.join(dir_path, '.gitignore')
+    if os.path.exists(gitignore_path):
+        with open(gitignore_path, 'r', encoding='utf-8', errors='ignore') as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith('#'):
+                    # Remove trailing slash for directory patterns to match effectively
+                    if line.endswith('/'):
+                        line = line[:-1]
+                    ignore_patterns.append(line)
+    return ignore_patterns
+
+def is_ignored(name, ignore_patterns):
+    for pattern in ignore_patterns:
+        if fnmatch.fnmatch(name, pattern) or fnmatch.fnmatch(name, pattern + '/*'):
+            return True
+    return False
+
+def generate_tree(dir_path, prefix="", depth=0, max_depth=3, ignore_patterns=None):
+    if depth > max_depth:
+        print(f"{prefix}└── ... (max depth reached)")
+        return
+        
+    if ignore_patterns is None:
+        ignore_patterns = parse_gitignore(dir_path)
+
+    try:
+        entries = sorted(os.listdir(dir_path))
+    except PermissionError:
+        print(f"{prefix}└── [Permission Denied]")
+        return
+
+    # Filter out ignored entries
+    entries = [e for e in entries if not is_ignored(e, ignore_patterns)]
+    
+    entries_count = len(entries)
+    for i, entry in enumerate(entries):
+        is_last = (i == entries_count - 1)
+        entry_path = os.path.join(dir_path, entry)
+        
+        connector = "└── " if is_last else "├── "
+        print(f"{prefix}{connector}{entry}")
+        
+        if os.path.isdir(entry_path):
+            extension = "    " if is_last else "│   "
+            generate_tree(entry_path, prefix + extension, depth + 1, max_depth, ignore_patterns)
+
+if __name__ == "__main__":
+    sys.stdout.reconfigure(encoding='utf-8')
+    if len(sys.argv) < 2:
+        print("Usage: python tree_viewer.py <directory_path> [max_depth]")
+        sys.exit(1)
+        
+    target_dir = sys.argv[1]
+    max_depth = int(sys.argv[2]) if len(sys.argv) > 2 else 3
+    
+    if not os.path.isdir(target_dir):
+        print(f"Error: Directory '{target_dir}' does not exist.")
+        sys.exit(1)
+        
+    print(f"Directory Tree for: {os.path.abspath(target_dir)} (Max Depth: {max_depth})")
+    print(".")
+    generate_tree(target_dir, max_depth=max_depth)