hanuscode 1.0.0__py3-none-any.whl

hanus/plugins/notes.py

@@ -0,0 +1,583 @@
+# plugins/notes.py — Knowledge management with bidirectional links
+"""
+Plugin for bidirectional note linking, tags, and knowledge graph.
+
+Commands:
+  /notes new <title>           — Create a new note
+  /notes edit <title>          — Edit a note
+  /notes view <title>          — View a note with backlinks
+  /notes delete <title>        — Delete a note
+  /notes list                  — List all notes
+  /notes search <query>        — Search notes by content
+  /notes tags                  — List all tags
+  /notes tag <tag>             — Notes with specific tag
+  /notes links <title>         — Show outgoing links from note
+  /notes backlinks <title>     — Show notes linking to this note
+  /notes graph                 — Show knowledge graph
+  /notes graph <title>         — Graph centered on note
+"""
+import re
+import json
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, List, Set, Optional, Tuple
+
+NAME = "notes"
+DESCRIPTION = "Knowledge management with bidirectional links"
+USAGE = "new|edit|view|delete|list|search|tags|tag|links|backlinks|graph <args>"
+
+AGENT_DOC = """
+Knowledge management plugin with bidirectional linking.
+
+## Commands:
+- new <title> [content] — Create note with optional content
+- edit <title> — Append content to note (use --replace to replace)
+- view <title> — View note with backlinks
+- delete <title> — Delete a note
+- list — List all notes
+- search <query> — Full-text search in notes
+- tags — List all tags used
+- tag <tag> — Show notes with specific tag
+- links <title> — Show outgoing [[links]] from note
+- backlinks <title> — Show notes linking to this note
+- graph — Display knowledge graph connections
+- graph <title> — Graph centered on specific note
+
+## Features:
+- Wiki-style [[links]] between notes
+- Backlinks (which notes reference this note)
+- #tags for categorization
+- Knowledge graph visualization
+- Full-text search
+
+## Link Syntax:
+- [[Note Title]] — Link to another note
+- [[Note Title|display text]] — Link with custom display text
+- #tag — Tag in note content
+
+Examples:
+  /notes new "Project Ideas" "Ideas for future projects #ideas"
+  /notes edit "Project Ideas" "New idea: [[AI Assistant]]"
+  /notes view "Project Ideas"
+  /notes graph "Project Ideas"
+  /obsidian view "Project Ideas"
+  /obsidian graph "Project Ideas"
+"""
+
+NOTES_DIR = Path.home() / ".hanus" / "notes"
+INDEX_FILE = NOTES_DIR / "_index.json"
+
+# Regex patterns
+LINK_PATTERN = re.compile(r'\[\[([^\]|]+)(?:\|[^\]]+)?\]\]')
+TAG_PATTERN = re.compile(r'#([\w\-]+)')
+
+
+def _ensure_notes_dir():
+    """Ensure notes directory exists."""
+    NOTES_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _normalize_title(title: str) -> str:
+    """Normalize note title for filename."""
+    # Remove invalid chars, lowercase, replace spaces with underscores
+    clean = re.sub(r'[<>:"/\\|?*]', '', title)
+    return clean.strip().lower().replace(' ', '_')
+
+
+def _get_note_path(title: str) -> Path:
+    """Get path for a note."""
+    return NOTES_DIR / f"{_normalize_title(title)}.md"
+
+
+def _get_all_notes() -> Dict[str, dict]:
+    """Load all notes with metadata."""
+    _ensure_notes_dir()
+    notes = {}
+    for path in NOTES_DIR.glob("*.md"):
+        if path.name.startswith("_"):
+            continue
+        try:
+            content = path.read_text(encoding="utf-8")
+            title = path.stem.replace('_', ' ').title()
+            links = set(LINK_PATTERN.findall(content))
+            tags = set(TAG_PATTERN.findall(content))
+            notes[title.lower()] = {
+                "title": title,
+                "path": path,
+                "content": content,
+                "links": links,
+                "tags": tags,
+                "modified": datetime.fromtimestamp(path.stat().st_mtime)
+            }
+        except Exception:
+            continue
+    return notes
+
+
+def _get_backlinks(title: str, notes: Dict[str, dict]) -> Set[str]:
+    """Get all notes that link to this note."""
+    backlinks = set()
+    title_lower = title.lower()
+    for note_title, note in notes.items():
+        if note_title == title_lower:
+            continue
+        # Check if this note links to the target
+        for link in note["links"]:
+            if link.lower() == title_lower:
+                backlinks.add(note["title"])
+    return backlinks
+
+
+def _build_graph(notes: Dict[str, dict]) -> Dict:
+    """Build knowledge graph."""
+    graph = {"nodes": [], "edges": []}
+    node_ids = {}
+
+    for title, note in notes.items():
+        node_id = len(graph["nodes"])
+        node_ids[title] = node_id
+        graph["nodes"].append({
+            "id": node_id,
+            "title": note["title"],
+            "tags": list(note["tags"]),
+            "modified": note["modified"].isoformat() if isinstance(note["modified"], datetime) else note["modified"]
+        })
+
+    added_edges = set()
+    for title, note in notes.items():
+        for link in note["links"]:
+            link_lower = link.lower()
+            if link_lower in node_ids and title != link_lower:
+                edge = (min(node_ids[title], node_ids[link_lower]),
+                        max(node_ids[title], node_ids[link_lower]))
+                if edge not in added_edges:
+                    graph["edges"].append({
+                        "source": node_ids[title],
+                        "target": node_ids[link_lower]
+                    })
+                    added_edges.add(edge)
+
+    return graph
+
+
+def run(args: str = "") -> str:
+    """Run obsidian command."""
+    if not args.strip():
+        return _cmd_list("")
+
+    parts = args.strip().split(maxsplit=1)
+    cmd = parts[0].lower()
+    arg = parts[1] if len(parts) > 1 else ""
+
+    commands = {
+        "new": _cmd_new,
+        "create": _cmd_new,
+        "edit": _cmd_edit,
+        "append": _cmd_edit,
+        "view": _cmd_view,
+        "show": _cmd_view,
+        "read": _cmd_view,
+        "delete": _cmd_delete,
+        "remove": _cmd_delete,
+        "rm": _cmd_delete,
+        "list": _cmd_list,
+        "ls": _cmd_list,
+        "search": _cmd_search,
+        "find": _cmd_search,
+        "tags": _cmd_tags,
+        "tag": _cmd_tag,
+        "links": _cmd_links,
+        "backlinks": _cmd_backlinks,
+        "refs": _cmd_backlinks,
+        "graph": _cmd_graph,
+        "connect": _cmd_graph,
+    }
+
+    handler = commands.get(cmd)
+    if not handler:
+        return f"Unknown command: {cmd}\nCommands: new, edit, view, delete, list, search, tags, tag, links, backlinks, graph"
+
+    return handler(arg)
+
+
+def _cmd_new(args: str) -> str:
+    """Create a new note."""
+    _ensure_notes_dir()
+
+    parts = args.strip().split(maxsplit=1)
+    if not parts:
+        return "Usage: /obsidian new <title> [content]"
+
+    title = parts[0].strip('"\'')
+    content = parts[1] if len(parts) > 1 else ""
+
+    # Add timestamp if no content
+    if not content:
+        content = f"# {title}\n\nCreated: {datetime.now().strftime('%Y-%m-%d %H:%M')}\n\n"
+
+    path = _get_note_path(title)
+
+    if path.exists():
+        return f"Note '{title}' already exists. Use /obsidian edit to modify."
+
+    path.write_text(content, encoding="utf-8")
+
+    # Extract and show info
+    links = LINK_PATTERN.findall(content)
+    tags = TAG_PATTERN.findall(content)
+
+    result = [f"Created note: {title}"]
+    if tags:
+        result.append(f"Tags: {', '.join('#' + t for t in tags)}")
+    if links:
+        result.append(f"Links: {', '.join('[[' + l + ']]' for l in links)}")
+
+    return "\n".join(result)
+
+
+def _cmd_edit(args: str) -> str:
+    """Edit a note (append or replace)."""
+    _ensure_notes_dir()
+
+    replace_mode = "--replace" in args
+    args = args.replace("--replace", "").strip()
+
+    parts = args.strip().split(maxsplit=1)
+    if len(parts) < 2:
+        return "Usage: /obsidian edit <title> <content> [--replace]"
+
+    title = parts[0].strip('"\'')
+    new_content = parts[1]
+
+    path = _get_note_path(title)
+
+    if not path.exists():
+        return f"Note '{title}' not found. Use /obsidian new to create it."
+
+    if replace_mode:
+        path.write_text(new_content, encoding="utf-8")
+        return f"Note '{title}' replaced."
+    else:
+        current = path.read_text(encoding="utf-8")
+        path.write_text(current + "\n\n" + new_content, encoding="utf-8")
+        return f"Appended to note '{title}'."
+
+
+def _cmd_view(args: str) -> str:
+    """View a note with backlinks."""
+    if not args.strip():
+        return "Usage: /obsidian view <title>"
+
+    title = args.strip().strip('"\'')
+    path = _get_note_path(title)
+
+    if not path.exists():
+        # Try fuzzy match
+        notes = _get_all_notes()
+        matches = [n for n in notes if title.lower() in n]
+        if matches:
+            return f"Note not found. Similar: {', '.join(notes[m]['title'] for m in matches[:5])}"
+        return f"Note '{title}' not found."
+
+    content = path.read_text(encoding="utf-8")
+    all_notes = _get_all_notes()
+    backlinks = _get_backlinks(title, all_notes)
+
+    result = [f"--- {title} ---", content]
+
+    if backlinks:
+        result.append(f"\n--- Backlinks ({len(backlinks)}) ---")
+        result.append(", ".join(f"[[{bl}]]" for bl in sorted(backlinks)))
+
+    # Show linked notes status
+    links = set(LINK_PATTERN.findall(content))
+    if links:
+        broken = [l for l in links if l.lower() not in all_notes]
+        if broken:
+            result.append(f"\n--- Broken Links ---")
+            result.append(", ".join(f"[[{b}]]?" for b in broken))
+
+    return "\n".join(result)
+
+
+def _cmd_delete(args: str) -> str:
+    """Delete a note."""
+    if not args.strip():
+        return "Usage: /obsidian delete <title>"
+
+    title = args.strip().strip('"\'')
+    path = _get_note_path(title)
+
+    if not path.exists():
+        return f"Note '{title}' not found."
+
+    # Check backlinks
+    all_notes = _get_all_notes()
+    backlinks = _get_backlinks(title, all_notes)
+
+    path.unlink()
+
+    result = [f"Deleted note: {title}"]
+    if backlinks:
+        result.append(f"Warning: {len(backlinks)} notes still link to this: {', '.join(backlinks)}")
+
+    return "\n".join(result)
+
+
+def _cmd_list(args: str) -> str:
+    """List all notes."""
+    notes = _get_all_notes()
+
+    if not notes:
+        return "No notes found. Create one with /obsidian new <title>"
+
+    lines = [f"Notes ({len(notes)}):"]
+    for title, note in sorted(notes.items()):
+        tags = f" [{', '.join('#' + t for t in note['tags'])}]" if note['tags'] else ""
+        links_count = len(note['links'])
+        backlinks = len(_get_backlinks(note['title'], notes))
+        lines.append(f"  • {note['title']}{tags}")
+        lines.append(f"    {links_count} links, {backlinks} backlinks")
+
+    return "\n".join(lines)
+
+
+def _cmd_search(args: str) -> str:
+    """Search notes by content."""
+    if not args.strip():
+        return "Usage: /obsidian search <query>"
+
+    query = args.strip().lower()
+    notes = _get_all_notes()
+
+    results = []
+    for title, note in notes.items():
+        if query in note['content'].lower():
+            # Find context around match
+            lines = note['content'].lower().split('\n')
+            matches = []
+            for i, line in enumerate(lines):
+                if query in line:
+                    start = max(0, i - 1)
+                    end = min(len(lines), i + 2)
+                    context = '\n'.join(lines[start:end])
+                    matches.append(context)
+                    if len(matches) >= 3:
+                        break
+            results.append((note['title'], matches[:3]))
+
+    if not results:
+        return f"No notes found matching '{query}'"
+
+    lines = [f"Search results for '{query}' ({len(results)} notes):"]
+    for title, matches in results:
+        lines.append(f"\n--- {title} ---")
+        for m in matches:
+            lines.append(m)
+
+    return "\n".join(lines)
+
+
+def _cmd_tags(args: str) -> str:
+    """List all tags."""
+    notes = _get_all_notes()
+
+    tag_counts: Dict[str, int] = {}
+    for note in notes.values():
+        for tag in note['tags']:
+            tag_counts[tag] = tag_counts.get(tag, 0) + 1
+
+    if not tag_counts:
+        return "No tags found. Add #tags to your notes."
+
+    lines = ["Tags:"]
+    for tag, count in sorted(tag_counts.items(), key=lambda x: (-x[1], x[0])):
+        lines.append(f"  #{tag} ({count} notes)")
+
+    return "\n".join(lines)
+
+
+def _cmd_tag(args: str) -> str:
+    """Show notes with specific tag."""
+    if not args.strip():
+        return "Usage: /obsidian tag <tagname>"
+
+    tag = args.strip().lstrip('#').lower()
+    notes = _get_all_notes()
+
+    matching = []
+    for note in notes.values():
+        if tag in [t.lower() for t in note['tags']]:
+            matching.append(note['title'])
+
+    if not matching:
+        return f"No notes with tag #{tag}"
+
+    return f"Notes with #{tag} ({len(matching)}):\n" + "\n".join(f"  • {t}" for t in sorted(matching))
+
+
+def _cmd_links(args: str) -> str:
+    """Show outgoing links from a note."""
+    if not args.strip():
+        return "Usage: /obsidian links <title>"
+
+    title = args.strip().strip('"\'')
+    notes = _get_all_notes()
+    note = notes.get(title.lower())
+
+    if not note:
+        return f"Note '{title}' not found."
+
+    links = note['links']
+    if not links:
+        return f"Note '{title}' has no outgoing links."
+
+    lines = [f"Links from '{title}' ({len(links)}):"]
+    for link in sorted(links):
+        status = "" if link.lower() in notes else " (broken)"
+        lines.append(f"  [[{link}]]{status}")
+
+    return "\n".join(lines)
+
+
+def _cmd_backlinks(args: str) -> str:
+    """Show notes linking to a note."""
+    if not args.strip():
+        return "Usage: /obsidian backlinks <title>"
+
+    title = args.strip().strip('"\'')
+    notes = _get_all_notes()
+
+    if title.lower() not in notes:
+        return f"Note '{title}' not found."
+
+    backlinks = _get_backlinks(title, notes)
+
+    if not backlinks:
+        return f"No notes link to '{title}'"
+
+    return f"Backlinks to '{title}' ({len(backlinks)}):\n" + "\n".join(f"  • [[{bl}]]" for bl in sorted(backlinks))
+
+
+def _cmd_graph(args: str) -> str:
+    """Display knowledge graph."""
+    notes = _get_all_notes()
+
+    if not notes:
+        return "No notes to graph."
+
+    if args.strip():
+        # Graph centered on specific note
+        center = args.strip().strip('"\'').lower()
+        if center not in notes:
+            return f"Note '{args.strip()}' not found."
+
+        # Get connected notes (2 hops)
+        connected = {center}
+        for link in notes[center]['links']:
+            if link.lower() in notes:
+                connected.add(link.lower())
+                # Second hop
+                for l2 in notes[link.lower()]['links']:
+                    if l2.lower() in notes:
+                        connected.add(l2.lower())
+
+        # Add backlinks
+        for title in list(connected):
+            for bl in _get_backlinks(title, notes):
+                connected.add(bl.lower())
+
+        # Filter notes to connected only
+        notes = {k: v for k, v in notes.items() if k in connected}
+
+    graph = _build_graph(notes)
+
+    # ASCII graph visualization
+    lines = ["Knowledge Graph:"]
+    lines.append("")
+
+    for node in sorted(graph["nodes"], key=lambda x: x["title"]):
+        title = node["title"]
+        links_out = [e for e in graph["edges"] if e["source"] == node["id"]]
+        links_in = [e for e in graph["edges"] if e["target"] == node["id"]]
+
+        tags = f" [{', '.join('#' + t for t in node['tags'])}]" if node['tags'] else ""
+        lines.append(f"  [{title}]{tags}")
+
+        if links_out:
+            targets = [graph["nodes"][e["target"]]["title"] for e in links_out]
+            lines.append(f"    → {', '.join(targets)}")
+        if links_in:
+            sources = [graph["nodes"][e["source"]]["title"] for e in links_in]
+            lines.append(f"    ← {', '.join(sources)}")
+        lines.append("")
+
+    # Stats
+    lines.append(f"Stats: {len(graph['nodes'])} notes, {len(graph['edges'])} connections")
+
+    return "\n".join(lines)
+
+
+# Tool interface for agent integration
+def create_note(title: str, content: str = "") -> str:
+    """Create a new note. Returns status message."""
+    return _cmd_new(f'"{title}" {content}'.strip())
+
+
+def append_to_note(title: str, content: str) -> str:
+    """Append content to a note. Returns status message."""
+    return _cmd_edit(f'"{title}" {content}')
+
+
+def get_note(title: str) -> Optional[str]:
+    """Get note content. Returns None if not found."""
+    path = _get_note_path(title)
+    if path.exists():
+        return path.read_text(encoding="utf-8")
+    return None
+
+
+def search_notes(query: str) -> List[Dict]:
+    """Search notes. Returns list of {title, content, matches}."""
+    notes = _get_all_notes()
+    query_lower = query.lower()
+    results = []
+
+    for note in notes.values():
+        if query_lower in note["content"].lower():
+            results.append({
+                "title": note["title"],
+                "content": note["content"],
+                "tags": list(note["tags"]),
+                "links": list(note["links"])
+            })
+
+    return results
+
+
+def get_linked_notes(title: str) -> Tuple[Set[str], Set[str]]:
+    """Get outgoing links and backlinks for a note."""
+    notes = _get_all_notes()
+    title_lower = title.lower()
+
+    if title_lower not in notes:
+        return set(), set()
+
+    outgoing = notes[title_lower]["links"]
+    backlinks = _get_backlinks(title, notes)
+
+    return outgoing, backlinks
+
+
+def get_all_tags() -> Dict[str, List[str]]:
+    """Get all tags with notes that use them."""
+    notes = _get_all_notes()
+    tag_notes: Dict[str, List[str]] = {}
+
+    for note in notes.values():
+        for tag in note["tags"]:
+            if tag not in tag_notes:
+                tag_notes[tag] = []
+            tag_notes[tag].append(note["title"])
+
+    return tag_notes

hanus/plugins/search_code.py

@@ -0,0 +1,59 @@
+# plugins/search_code.py — Búsqueda avanzada en código
+import re
+from pathlib import Path
+
+NAME        = "search_code"
+DESCRIPTION = "Busca texto o regex en archivos del proyecto"
+USAGE       = "<término> [--ext .py] [--regex]"
+AGENT_DOC   = (
+    "Busca texto o regex en el código. "
+    "Ej: 'def mi_func', 'TODO --ext .py', 'import requests --regex'. "
+    "Retorna archivo, línea y contexto."
+)
+
+IGNORE = {".git","__pycache__","venv",".venv","node_modules","dist","build",".mypy_cache"}
+EXTS   = {".py",".js",".ts",".jsx",".tsx",".md",".txt",".yaml",".yml",".toml",
+          ".json",".ini",".cfg",".html",".css",".go",".rs",".java",".rb",".sh",".c",".cpp",".h"}
+MAX    = 60
+
+
+def run(args: str = "") -> str:
+    if not args.strip():
+        return "Uso: search_code <término> [--ext .py] [--regex]"
+    use_regex = "--regex" in args
+    args      = args.replace("--regex","").strip()
+    ext_m     = re.search(r"--ext\s+(\S+)", args)
+    ext_filter = None
+    if ext_m:
+        ext_filter = ext_m.group(1)
+        args       = args.replace(ext_m.group(0),"").strip()
+    term = args.strip()
+    if not term:
+        return "Indica un término de búsqueda."
+    root  = Path(".").resolve()
+    found = []
+    for path in _files(root, ext_filter):
+        try:
+            text = path.read_text(encoding="utf-8", errors="replace")
+        except Exception:
+            continue
+        for i, line in enumerate(text.splitlines(), 1):
+            hit = bool(re.search(term, line)) if use_regex else term.lower() in line.lower()
+            if hit:
+                found.append(f"{path.relative_to(root)}:{i}  {line.strip()}")
+                if len(found) >= MAX: break
+        if len(found) >= MAX: break
+    if not found:
+        return f"Sin resultados para '{term}'."
+    plus = "+" if len(found) == MAX else ""
+    return f"Resultados para '{term}' ({len(found)}{plus}):\n" + "\n".join(found)
+
+
+def _files(root: Path, ext_filter):
+    for item in root.rglob("*"):
+        if not item.is_file(): continue
+        if any(p in item.parts for p in IGNORE): continue
+        if ext_filter:
+            if item.suffix.lower() != ext_filter.lower(): continue
+        elif item.suffix.lower() not in EXTS: continue
+        yield item