agent-notes 2.14.0__tar.gz → 2.15.1__tar.gz

{agent_notes-2.14.0 → agent_notes-2.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-notes
-Version: 2.14.0
+Version: 2.15.1
 Summary: AI agent configuration manager for Claude Code, OpenCode, and Copilot
 Author-email: Eugene Naumov <min.verkligheten@gmail.com>
 License-Expression: MIT

agent_notes-2.15.1/agent_notes/VERSION

@@ -0,0 +1 @@
+2.15.1

{agent_notes-2.14.0 → agent_notes-2.15.1}/agent_notes/cli.py

@@ -282,7 +282,7 @@ def main():
     # memory
     p_memory = subparsers.add_parser("memory", help="Manage agent memory")
     p_memory.add_argument("action", nargs="?", default="list",
-        choices=["init", "list", "vault", "index", "add", "size", "show", "reset", "export", "import"],
+        choices=["init", "list", "vault", "index", "add", "size", "show", "reset", "export", "import", "ingest", "query", "lint"],
         help="Memory action")
     p_memory.add_argument("name", nargs="?", help="Agent name / note title (for show/reset/add)")
     p_memory.add_argument("extra", nargs="*", help="Additional args (for add: body [type] [agent] [project])")

{agent_notes-2.14.0 → agent_notes-2.15.1}/agent_notes/commands/memory.py

@@ -43,6 +43,13 @@ def do_init() -> None:
     if path is None:
         print("Memory path not configured.")
         return
+    if backend == "wiki":
+        from ..services.wiki_backend import wiki_init, WIKI_PAGE_TYPES
+        wiki_init(path)
+        print(f"{Color.GREEN}Wiki initialised at {path}{Color.NC}")
+        print(f"  Folders: raw/, wiki/{{{', '.join(WIKI_PAGE_TYPES)}}}")
+        print(f"  Index:   {path / 'wiki' / 'index.md'}")
+        return
     if backend == "obsidian":
         from ..services.memory_backend import obsidian_init, OBSIDIAN_CATEGORIES
         obsidian_init(path)
@@ -65,7 +72,11 @@ def do_index() -> None:
     if path is None:
         print("Memory path not configured.")
         return
-    if backend == "obsidian":
+    if backend == "wiki":
+        from ..services.wiki_backend import wiki_regenerate_index
+        wiki_regenerate_index(path)
+        print(f"{Color.GREEN}index.md regenerated at {path / 'wiki' / 'index.md'}{Color.NC}")
+    elif backend == "obsidian":
         from ..services.memory_backend import obsidian_regenerate_index
         obsidian_regenerate_index(path)
         print(f"{Color.GREEN}Index.md regenerated at {path / 'Index.md'}{Color.NC}")
@@ -75,8 +86,21 @@ def do_index() -> None:
         print(f"{Color.GREEN}Index.md regenerated at {path / 'Index.md'}{Color.NC}")
 
 
+_WIKI_TYPE_MAP = {
+    "pattern": "concepts",
+    "decision": "concepts",
+    "mistake": "concepts",
+    "context": "concepts",
+    "concept": "concepts",
+    "entity": "entities",
+    "synthesis": "synthesis",
+    "session": "sessions",
+    "source": "sources",
+}
+
+
 def do_add(title: str, body: str, note_type: str = "context", agent: str = "", project: str = "", tags: Optional[list] = None) -> None:
-    """Add a note to memory (obsidian backend only for structured notes)."""
+    """Add a note to memory (obsidian or wiki backend)."""
     backend, path = _load_memory_config()
     if backend == "none":
         print("Memory is disabled. Run `agent-notes memory vault` to check configuration.")
@@ -84,7 +108,21 @@ def do_add(title: str, body: str, note_type: str = "context", agent: str = "", p
     if path is None:
         print("Memory path not configured.")
         return
-    if backend == "obsidian":
+    if backend == "wiki":
+        from ..services.wiki_backend import wiki_write_page
+        page_type = _WIKI_TYPE_MAP.get(note_type, "concepts")
+        extra_tags = [note_type] if note_type not in ("concept", "entity", "synthesis", "session", "source") else []
+        page_path = wiki_write_page(
+            path,
+            title=title,
+            body=body,
+            page_type=page_type,
+            agent=agent,
+            project=project,
+            tags=(tags or []) + extra_tags,
+        )
+        print(f"{Color.GREEN}Wiki page saved: {page_path}{Color.NC}")
+    elif backend == "obsidian":
         from ..services.memory_backend import obsidian_init, obsidian_write_note
         obsidian_init(path)
         note_path = obsidian_write_note(
@@ -98,7 +136,7 @@ def do_add(title: str, body: str, note_type: str = "context", agent: str = "", p
         )
         print(f"{Color.GREEN}Note saved: {note_path}{Color.NC}")
     else:
-        print("The `add` subcommand is for the obsidian backend.")
+        print("The `add` subcommand is for the obsidian or wiki backend.")
         print("For local backend, write files directly to the agent subdirectory.")
 
 
@@ -110,6 +148,26 @@ def do_list() -> None:
         print("Memory is disabled. Run `agent-notes memory backend` to enable it.")
         return
 
+    if backend == "wiki":
+        if path is None or not path.exists():
+            print(f"Wiki not found at {path}")
+            return
+        from ..services.wiki_backend import wiki_list_pages
+        pages = wiki_list_pages(path)
+        if not pages:
+            print(f"No pages found in wiki {path}")
+            return
+        print(f"Wiki ({path}):")
+        print("")
+        current_type = None
+        for page in pages:
+            if page["type"] != current_type:
+                current_type = page["type"]
+                print(f"  {Color.CYAN}{current_type}{Color.NC}")
+            tags_str = f"  [{', '.join(page['tags'])}]" if page["tags"] else ""
+            print(f"    {page['file']}{tags_str}")
+        return
+
     if backend == "obsidian":
         if path is None or not path.exists():
             print(f"Obsidian vault not found at {path}")
@@ -361,6 +419,96 @@ def format_size(size_bytes: int) -> str:
     return f"{original_size:.1f}P"
 
 
+def do_ingest(title: str, body: str, concepts: Optional[list] = None, entities: Optional[list] = None, tags: Optional[list] = None) -> None:
+    """Ingest a source into the wiki backend."""
+    backend, path = _load_memory_config()
+    if backend != "wiki":
+        print("The `ingest` subcommand is only available for the wiki backend.")
+        return
+    if path is None:
+        print("Memory path not configured.")
+        return
+    from ..services.wiki_backend import wiki_ingest
+    result = wiki_ingest(
+        path,
+        title=title,
+        body=body,
+        concepts=concepts or [],
+        entities=entities or [],
+        tags=tags or [],
+    )
+    source_paths = result.get("source", [])
+    concept_paths = result.get("concepts", [])
+    entity_paths = result.get("entities", [])
+    print(f"{Color.GREEN}Ingested: {title}{Color.NC}")
+    for p in source_paths:
+        print(f"  source:  {p}")
+    for p in concept_paths:
+        print(f"  concept: {p}")
+    for p in entity_paths:
+        print(f"  entity:  {p}")
+
+
+def do_query(keyword: str) -> None:
+    """Search wiki pages by keyword."""
+    backend, path = _load_memory_config()
+    if backend != "wiki":
+        print("The `query` subcommand is only available for the wiki backend.")
+        return
+    if path is None:
+        print("Memory path not configured.")
+        return
+    from ..services.wiki_backend import wiki_query
+    results = wiki_query(path, keyword)
+    if not results:
+        print(f"No results found for: {keyword}")
+        return
+    print(f"Results for '{keyword}' ({len(results)} found):")
+    print("")
+    for r in results:
+        print(f"  {Color.CYAN}[{r['type']}]{Color.NC} {r['title']}")
+        print(f"    {r['path']}")
+        if r["snippet"]:
+            print(f"    ...{r['snippet']}...")
+        print("")
+
+
+def do_lint() -> None:
+    """Check wiki health."""
+    backend, path = _load_memory_config()
+    if backend != "wiki":
+        print("The `lint` subcommand is only available for the wiki backend.")
+        return
+    if path is None:
+        print("Memory path not configured.")
+        return
+    from ..services.wiki_backend import wiki_lint
+    issues = wiki_lint(path)
+    orphans = issues.get("orphans", [])
+    broken = issues.get("broken_links", [])
+    stale = issues.get("stale_index", [])
+
+    if not orphans and not broken and not stale:
+        print(f"{Color.GREEN}Wiki is healthy — no issues found.{Color.NC}")
+        return
+
+    if orphans:
+        print(f"{Color.YELLOW}Orphans ({len(orphans)} pages not linked from anywhere):{Color.NC}")
+        for p in orphans:
+            print(f"  {p}")
+        print("")
+    if broken:
+        print(f"{Color.YELLOW}Broken links ({len(broken)}):{Color.NC}")
+        for b in broken:
+            print(f"  {b}")
+        print("")
+    if stale:
+        print(f"{Color.YELLOW}Stale index ({len(stale)} pages newer than index.md):{Color.NC}")
+        for s in stale:
+            print(f"  {s}")
+        print(f"  Run: agent-notes memory index")
+
+
 def do_migrate() -> None:
     """Migrate vault from per-project layout to flat shared layout with new filenames."""
     import re
@@ -574,6 +722,25 @@ def memory(action: str = "list", name: Optional[str] = None, extra: Optional[lis
         do_import()
     elif action == "migrate":
         do_migrate()
+    elif action == "ingest":
+        if not name:
+            print("Error: ingest requires a title.")
+            exit(1)
+        body = extra[0] if extra else ""
+        concepts_csv = extra[1] if extra and len(extra) > 1 else ""
+        entities_csv = extra[2] if extra and len(extra) > 2 else ""
+        tags_csv = extra[3] if extra and len(extra) > 3 else ""
+        concepts = [c.strip() for c in concepts_csv.split(",") if c.strip()] if concepts_csv else None
+        entities = [e.strip() for e in entities_csv.split(",") if e.strip()] if entities_csv else None
+        tags = [t.strip() for t in tags_csv.split(",") if t.strip()] if tags_csv else None
+        do_ingest(name, body, concepts=concepts, entities=entities, tags=tags)
+    elif action == "query":
+        if not name:
+            print("Error: query requires a keyword.")
+            exit(1)
+        do_query(name)
+    elif action == "lint":
+        do_lint()
     else:
         print(f"Unknown command: {action}")
         show_help()

{agent_notes-2.14.0 → agent_notes-2.15.1}/agent_notes/commands/wizard.py

@@ -339,7 +339,12 @@ def _render_install_summary(clis: Set[str], scope: str, copy_mode: bool, selecte
         print(f"  {_DIM}Skills{_NC}    {', '.join(parts) if parts else 'none'}")
 
     if memory_backend and memory_backend != "none":
-        mem_label = (f"Obsidian  →  {memory_path}" if memory_path else "Obsidian") if memory_backend == "obsidian" else "Local markdown"
+        if memory_backend == "obsidian":
+            mem_label = f"Obsidian (session)  →  {memory_path}" if memory_path else "Obsidian (session)"
+        elif memory_backend == "wiki":
+            mem_label = f"Obsidian (wiki)  →  {memory_path}" if memory_path else "Obsidian (wiki)"
+        else:
+            mem_label = "Local markdown"
         print(f"  {_DIM}Memory{_NC}    {mem_label}")
 
     # ── Per-CLI sections ──────────────────────────────────────────────────────
@@ -407,7 +412,8 @@ def _select_memory(step: int, total: int, version: str = '') -> tuple:
 
     options = [
         ("Local markdown files  (~/.claude/agent-memory/)", "local"),
-        ("Obsidian vault", "obsidian"),
+        ("Obsidian vault (session-oriented)", "obsidian"),
+        ("Obsidian vault (wiki)", "wiki"),
         ("None  (disable memory)", "none"),
     ]
 
@@ -430,8 +436,12 @@ def _select_memory(step: int, total: int, version: str = '') -> tuple:
         default_path = str(_mem_base / "agent-notes")
         raw = _safe_input(f"  Memory folder path [{default_path}]: ", default_path)
         path = raw.strip() or default_path
+    elif backend == "wiki":
+        default_path = str(Path.home() / "Documents" / "Obsidian Vault" / "agent-wiki")
+        raw = _safe_input(f"  Wiki folder path [{default_path}]: ", default_path)
+        path = raw.strip() or default_path
 
-    label = {"local": "Local markdown", "obsidian": f"Obsidian ({path})", "none": "Disabled"}[backend]
+    label = {"local": "Local markdown", "obsidian": f"Obsidian (session)  ({path})", "wiki": f"Obsidian (wiki)  ({path})", "none": "Disabled"}[backend]
     print(f"  {Color.GREEN}✓{Color.NC} Memory: {label}")
     return backend, path
 
@@ -718,7 +728,11 @@ def _interactive_install() -> None:
         try:
             if memory_backend == "obsidian":
                 obsidian_init(_mem_path)
-                memory_label = f"Obsidian  →  {_mem_path}"
+                memory_label = f"Obsidian (session)  →  {_mem_path}"
+            elif memory_backend == "wiki":
+                from ..services.wiki_backend import wiki_init
+                wiki_init(_mem_path)
+                memory_label = f"Obsidian (wiki)  →  {_mem_path}"
             else:
                 local_init(_mem_path)
                 memory_label = f"Local markdown  →  {_mem_path}"

{agent_notes-2.14.0 → agent_notes-2.15.1}/agent_notes/config.py

@@ -46,6 +46,8 @@ def memory_dir_for_backend(backend: str, custom_path: str = "") -> Optional[Path
         return Path(custom_path).expanduser()
     if backend == "obsidian":
         return Path.home() / "Documents" / "Obsidian Vault" / "agent-notes"
+    if backend == "wiki":
+        return Path.home() / "Documents" / "Obsidian Vault" / "agent-wiki"
     return MEMORY_DIR  # local default: ~/.claude/agent-memory
 
 def get_version() -> str:

{agent_notes-2.14.0 → agent_notes-2.15.1}/agent_notes/domain/state.py

@@ -7,7 +7,7 @@ from typing import Optional
 
 @dataclass
 class MemoryConfig:
-    backend: str = "local"   # "obsidian" | "local" | "none"
+    backend: str = "local"   # "obsidian" | "local" | "wiki" | "none"
     path: str = ""           # vault root (obsidian) or memory dir (local). empty = use default
 
 

{agent_notes-2.14.0 → agent_notes-2.15.1}/agent_notes/services/memory_backend.py

@@ -315,7 +315,7 @@ def obsidian_regenerate_index(vault: Path) -> None:
             display_dt = f"{dt_str[:10]} {dt_str[11:16]}"
         else:
             display_dt = dt_str[:16] if len(dt_str) >= 16 else dt_str
-        project = meta.get("project", "")
+        project = meta.get("project", "") or _current_project_name()
         lines.append(f"- [[{stem}|{display_dt}]] - {project}({meta['type']})")
 
     (vault / "Index.md").write_text("\n".join(lines) + "\n")