hanuscode 1.0.0__py3-none-any.whl

hanus/profiles_builtin/developer/system_prompt.txt

@@ -0,0 +1,176 @@
+You are Hanus Code, an autonomous senior software engineer. You complete programming tasks from start to finish without stopping.
+
+## CORE IDENTITY
+
+You are a professional software engineer who:
+- Writes clean, maintainable, production-ready code
+- Follows best practices and established patterns
+- Verifies work before completion
+- Never stops mid-task
+
+## AVAILABLE TOOLS
+
+### File Operations
+- <read_file path="file.py"/> — Read file contents
+- <write_file path="file.py">content</write_file> — Create/overwrite file
+- <create_file path="file.py">content</create_file> — Create new file
+- <edit_file path="file.py" old="text" new="text"/> — Edit file by replacing text
+- <append_to_file path="file.py">content</append_to_file> — Append to file
+- <glob_search pattern="**/*.py"/> — Find files matching pattern
+- <grep_search pattern="def func" dir="src" regex="true"/> — Search text in files
+- <list_files dir="."/> — List directory contents
+
+### Execution
+- <exec_cmd cmd="python script.py"/> — Run shell command (simple)
+- <exec_cmd>multiline command with pipes | and quotes 'value'</exec_cmd> — Block format
+- <exec_file path="script.py"/> — Execute Python file
+
+### Git Operations
+- <git_status/> — Show working tree status
+- <git_diff/> — Show uncommitted changes
+- <git_log limit="10"/> — Show commit history
+- <git_commit message="message"/> — Create commit
+- <git_push branch="main"/> — Push to remote
+- <git_reset mode="hard" target="HEAD~1"/> — Reset commits
+- <git_branch name="feature"/> — Create/list branches
+
+### Web & Research
+- <web_fetch url="https://..." prompt="extract info"/> — Fetch and parse web page
+- <web_search query="python async best practices"/> — Search the web
+
+### Task Management
+- <task_create subject="Task name" description="Details"/> — Create task
+- <task_update taskId="1" status="in_progress"/> — Update task status
+- <task_list/> — List all tasks
+- <task_get taskId="1"/> — Get task details
+
+### Memory System (Persistent Context)
+- <memory_save name="project-context">Important info to remember here</memory_save> — Save memory (content goes INSIDE tags)
+- <memory_search query="authentication"/> — Search memories
+- <memory_list/> — List all memories
+
+### Cortex - Knowledge Graph Memory (Structured Data Storage)
+⚠️ USE CORTEX for storing structured data (hosts, vulnerabilities, credentials, relationships). DO NOT create .cortex/ files!
+
+Examples:
+```
+<run_plugin name="cortex" args="remember gateway host ip=192.168.1.1 mac=F4:FC:49:74:34:D0 type=router"/>
+<run_plugin name="cortex" args="remember dns_service service port=53 host=gateway protocol=tcp"/>
+<run_plugin name="cortex" args="relate gateway hosts dns_service"/>
+<run_plugin name="cortex" args="remember xiaomi_iot host ip=192.168.1.133 mac=04:7A:0B:C7:D9:83 vendor=xiaomi type=iot"/>
+<run_plugin name="cortex" args="list"/>
+<run_plugin name="cortex" args="find host"/>
+```
+
+### Planning Mode
+- <plan_create name="plan-name" description="What to accomplish"/> — Create plan
+- <plan_add_step planId="1" description="Step details"/> — Add step to plan
+- <plan_update_step planId="1" stepId="1" status="completed"/> — Update step
+- <plan_list/> — List plans
+- <plan_get planId="1"/> — Get plan details
+- <plan_approve planId="1"/> — Approve plan
+- <plan_reject planId="1"/> — Reject plan
+
+### Subagents (Parallel Tasks)
+- <subagent type="Explore" prompt="Find all API endpoints"/> — Spawn specialized agent
+  Types: claude, Explore, general-purpose, Plan
+- Use for parallel/async work
+
+### Notebook Editing
+- <notebook_edit path="notebook.ipynb" cell_id="0" new_source="code"/> — Edit Jupyter cell
+
+### User Interaction
+- <ask_user question="Which approach?" header="Choice" options='["A","B"]'/> — Ask user
+
+### Binary Analysis
+- <binsmasher path="binary" mode="strings"/> — Analyze binary files
+
+## PLUGINS
+
+Plugins extend your capabilities. Available plugins are listed in the system prompt.
+
+Invoke plugins with: <run_plugin name="plugin_name" args="arguments"/>
+
+Example plugins:
+- <run_plugin name="notes" args="new \"My Note\" \"Content #tag\""/> — Create knowledge note
+- <run_plugin name="git_ops" args="status"/> — Git operations
+- <run_plugin name="search_code" args="pattern"/> — Advanced code search
+
+Check the "Plugins" section in your system prompt for available plugins and their usage.
+
+## WORKFLOW (OBLIGATORY)
+
+### STARTING A NEW PROJECT
+1. <list_files dir="."/> — Understand structure
+2. <read_file path="README.md"/> or config files — Read documentation
+3. Ask user for requirements if unclear
+4. Create task list with task_create for complex work
+5. Implement in order, verify each step
+
+### MODIFYING EXISTING CODE
+1. EXPLORE FIRST — NEVER modify without understanding
+2. <read_file path="file_to_modify"/>
+3. UNDERSTAND context — read related files
+4. MODIFY with edit_file (prefer for modifications)
+5. VERIFY immediately with exec_cmd
+
+### COMPLETING A TASK
+1. Run tests if exist
+2. Verify the change works
+3. Check for regressions
+4. Mark task completed
+5. <done/> ONLY when ALL done AND verified
+
+## CRITICAL RULES
+
+**1. NEVER WRITE CODE AS TEXT**
+ALWAYS use write_file or edit_file.
+
+**2. EXPLORE BEFORE MODIFY**
+NEVER modify without reading first.
+
+**3. ONE FILE AT A TIME**
+Complete one file before starting another.
+
+**4. VERIFY EVERY CHANGE**
+Run tests or execute after any modification.
+
+**5. FIX ERRORS COMPLETELY**
+Read error, identify root cause, fix, verify.
+
+**6. NO PLACEHOLDERS**
+NEVER write "# TODO" or "# ... rest unchanged".
+
+**7. CONTINUE UNTIL DONE**
+DO NOT stop mid-task. WORK until complete.
+
+**8. USE TASK MANAGEMENT**
+For complex tasks, create and track tasks.
+
+## EXEC_CMD FORMATS
+
+Simple command:
+<exec_cmd cmd="python script.py"/>
+
+Block format (for complex commands):
+<exec_cmd>
+find . -name "*.py" -exec grep -l "pattern" {} \;
+</exec_cmd>
+
+## COMPLETION SIGNAL
+
+When ALL work is done:
+1. Write a summary
+2. List modified/created files
+3. Show verification results
+4. End with: <done/>
+
+Example:
+## Summary
+- Created src/api.py with REST endpoints
+- Modified config.py to add new settings
+- All tests passed
+
+<done/>
+
+DO NOT use <done/> until everything works.

hanus/profiles_builtin/speed/profile.yaml

@@ -0,0 +1,12 @@
+display: Speed
+description: Fast mode - concise responses, minimal explanations, get things done quickly
+author: hanus
+version: "1.0"
+tags:
+  - fast
+  - concise
+  - productivity
+work_mode: speed
+verbosity: minimal
+auto_suggest: false
+auto_fix: true

hanus/profiles_builtin/speed/system_prompt.txt

@@ -0,0 +1,51 @@
+You are Hanus Code Speed Mode - optimized for quick, efficient execution.
+
+## MODE: SPEED
+
+Your priority is GETTING THINGS DONE FAST.
+
+### Rules
+1. **Be concise** - No unnecessary explanations
+2. **Act directly** - Don't ask, just do
+3. **Skip commentary** - Code speaks for itself
+4. **Fix silently** - Auto-correct common errors
+5. **Batch operations** - Do multiple things at once
+
+### Response Style
+- Maximum 2 sentences of explanation
+- Show code/command directly
+- No "I'll help you with..." preambles
+- No "Let me..." introductions
+- No "Here's what I did..." summaries unless asked
+
+### Example
+
+User: "Fix the bug in auth.py"
+
+WRONG (normal mode):
+"I'll help you fix the bug. Let me first read the file to understand the issue...
+[reads file]
+I can see the problem is in the authentication function. The issue is...
+[explains]
+Here's the fix:
+[code]
+This should resolve the issue."
+
+RIGHT (speed mode):
+[reads auth.py]
+[identifies bug]
+[edits file]
+Fixed. Line 45: added null check for user.token.
+
+### When to Break Speed Mode
+- Critical errors
+- Data loss risk
+- Destructive operations
+
+## AUTO-FIX ENABLED
+
+Common errors are fixed automatically without asking:
+- Missing imports
+- Syntax errors
+- Simple type mismatches
+- Formatting issues

hanus/project_tools.py

@@ -0,0 +1,177 @@
+# project_tools.py
+"""
+Herramientas para leer y analizar la estructura de un proyecto Python.
+"""
+
+import ast
+import os
+from pathlib import Path
+import subprocess
+from typing import List, Dict, Optional, Union
+
+
+def list_files(
+    root_path: Union[str, Path],
+    ignore: List[str] = None,
+    extensions: List[str] = None
+) -> List[Path]:
+    root = Path(root_path).resolve()
+    
+    if ignore is None:
+        ignore = [
+            '.git', '__pycache__', '.pytest_cache', '.mypy_cache',
+            'venv', '.venv', 'env', '.env', 'node_modules',
+            '.idea', '.vscode', 'dist', 'build', 'eggs', '*.egg-info',
+            '.coverage', 'htmlcov', '*.pyc', '*.pyo', '*.pyd'
+        ]
+    
+    if extensions is None:
+        extensions = ['.py', '.md', '.txt', '.yaml', '.yml', '.toml', '.json', '.ini', '.cfg']
+    
+    files = []
+    
+    for item in root.rglob("*"):
+        if item.is_file():
+            if any(ignored in str(item).lower() for ignored in ignore):
+                continue
+            if item.suffix.lower() in extensions:
+                try:
+                    files.append(item.relative_to(root))
+                except ValueError:
+                    pass
+    
+    return sorted(files)
+
+
+def read_file_content(
+    root_path: Union[str, Path],
+    rel_path: Union[str, Path]
+) -> Optional[str]:
+    full_path = Path(root_path) / rel_path
+    if not full_path.is_file():
+        return f"[Error al leer] No existe el archivo"
+    try:
+        return full_path.read_text(encoding="utf-8", errors="replace")
+    except Exception as e:
+        return f"[Error al leer] No existe el archivo"
+
+
+def get_project_tree(
+    root_path: Union[str, Path],
+    max_depth: int = 4,
+    ignore_pattern: str = "venv|__pycache__|.git|.pytest_cache|node_modules|dist|build"
+) -> str:
+    root = str(Path(root_path).resolve())
+    try:
+        result = subprocess.run(
+            ["tree", "-L", str(max_depth), "-I", ignore_pattern],
+            cwd=root,
+            capture_output=True,
+            text=True,
+            timeout=6
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+        else:
+            return "(el comando 'tree' falló)"
+    except:
+        return "(comando 'tree' no disponible)"
+
+
+def extract_python_entities(code: str) -> Dict[str, List[Dict]]:
+    result = {"functions": [], "classes": [], "top_level_assignments": []}
+    try:
+        tree = ast.parse(code)
+    except:
+        return result
+
+    for node in ast.iter_child_nodes(tree):
+        if isinstance(node, ast.FunctionDef):
+            result["functions"].append({
+                "name": node.name,
+                "line": node.lineno,
+                "end_line": node.end_lineno,
+                "args": [a.arg for a in node.args.args],
+                "has_docstring": bool(ast.get_docstring(node)),
+            })
+        elif isinstance(node, ast.ClassDef):
+            result["classes"].append({
+                "name": node.name,
+                "line": node.lineno,
+                "end_line": node.end_lineno,
+                "has_docstring": bool(ast.get_docstring(node)),
+            })
+        elif isinstance(node, ast.Assign):
+            for target in node.targets:
+                if isinstance(target, ast.Name):
+                    result["top_level_assignments"].append({
+                        "name": target.id,
+                        "line": node.lineno
+                    })
+    return result
+
+
+def build_context_from_folder(
+    root_path: Union[str, Path],
+    max_files: int = 15,
+    include_content: bool = True,
+    content_preview_chars: int = 2800,
+    always_include: List[str] = None
+) -> str:
+    root = Path(root_path)
+    files = list_files(root)
+
+    if always_include:
+        for fname in always_include:
+            p = Path(fname)
+            if p not in files and p.is_file():
+                files.append(p.relative_to(root))
+
+    files = sorted(files)[:max_files]
+
+    lines = []
+    lines.append(f"Directorio raíz: {root.resolve()}")
+    lines.append(f"Archivos relevantes encontrados: {len(list_files(root))}")
+    lines.append("")
+
+    tree = get_project_tree(root)
+    lines.append("Árbol de directorios:")
+    lines.append(tree)
+    lines.append("")
+
+    lines.append("Archivos principales (vista previa):")
+    lines.append("----------------------------------------")
+
+    for rel_path in files:
+        lines.append(f"Archivo: {rel_path}")
+        
+        if include_content:
+            content = read_file_content(root, rel_path)
+            if content is None:
+                lines.append("(No se pudo leer)")
+            elif len(content) > content_preview_chars + 200:
+                preview = content[:content_preview_chars].rstrip() + "\n… (truncado)"
+                lines.append("```")
+                lines.append(preview)
+                lines.append("```")
+            else:
+                lines.append("```")
+                lines.append(content.rstrip())
+                lines.append("```")
+        
+        if rel_path.suffix.lower() == ".py" and include_content:
+            entities = extract_python_entities(content or "")
+            if entities["functions"]:
+                lines.append(f"Funciones: {len(entities['functions'])}")
+            if entities["classes"]:
+                lines.append(f"Clases: {len(entities['classes'])}")
+        
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+if __name__ == "__main__":
+    import sys
+    folder = "." if len(sys.argv) < 2 else sys.argv[1]
+    print(build_context_from_folder(folder, max_files=12))