agent-notes 2.13.0__tar.gz → 2.15.0__tar.gz

{agent_notes-2.13.0 → agent_notes-2.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-notes
-Version: 2.13.0
+Version: 2.15.0
 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.0/agent_notes/VERSION

@@ -0,0 +1 @@
+2.15.0

{agent_notes-2.13.0 → agent_notes-2.15.0}/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.13.0 → agent_notes-2.15.0}/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.13.0 → agent_notes-2.15.0}/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.13.0 → agent_notes-2.15.0}/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.13.0 → agent_notes-2.15.0}/agent_notes/services/memory_backend.py

@@ -53,6 +53,12 @@ def _current_session_id() -> Optional[str]:
     return None
 
 
+def _current_project_name() -> str:
+    """Return the current working directory's name as the project name."""
+    name = Path.cwd().name
+    return name or ""
+
+
 # ── Obsidian backend ───────────────────────────────────────────────────────────
 
 def obsidian_init(vault: Path) -> None:
@@ -107,9 +113,12 @@ def _build_note(
     agent: str,
     session_stem: Optional[str],
     created_at: str,
+    project: str = "",
 ) -> str:
     """Render the canonical note content (frontmatter + heading + body + Related section)."""
     lines = ["---", f"created_at: {created_at}", f"type: {note_type}"]
+    if project:
+        lines.append(f"project: {project}")
     if session_stem and note_type != "session":
         lines.append(f"session: {session_stem}")
     if agent:
@@ -178,6 +187,9 @@ def obsidian_write_note(
     else:
         session_id = None
 
+    if not project:
+        project = _current_project_name()
+
     today = _today()
 
     if note_type == "session" and session_id:
@@ -185,7 +197,7 @@ def obsidian_write_note(
         # But first check if an existing file already has this session_id (any date prefix)
         existing = _find_session_note(vault, session_id)
         if existing is not None:
-            # Append to existing session note
+            # Append to existing session note — preserve existing frontmatter (including project)
             text = existing.read_text()
             fm, existing_body = _parse_frontmatter(text)
             if "created_at" not in fm:
@@ -193,6 +205,9 @@ def obsidian_write_note(
                 if re.fullmatch(r"\d{4}-\d{2}-\d{2}", created_at):
                     created_at = f"{created_at}T00:00:00Z"
                 new_fm_lines = ["---", f"created_at: {created_at}", f"type: {note_type}"]
+                existing_project = fm.get("project", "")
+                if existing_project:
+                    new_fm_lines.append(f"project: {existing_project}")
                 if agent:
                     new_fm_lines.append(f"agent: {agent}")
                 new_fm_lines.append("---")
@@ -206,7 +221,7 @@ def obsidian_write_note(
         path = folder / filename
         path.write_text(_build_note(
             title=title, body=body, note_type=note_type,
-            agent=agent, session_stem=None, created_at=created_at,
+            agent=agent, session_stem=None, created_at=created_at, project=project,
         ))
     elif note_type == "session":
         # No session_id available — fall back to timestamp+slug
@@ -215,7 +230,7 @@ def obsidian_write_note(
         path = folder / filename
         path.write_text(_build_note(
             title=title, body=body, note_type=note_type,
-            agent=agent, session_stem=None, created_at=created_at,
+            agent=agent, session_stem=None, created_at=created_at, project=project,
         ))
     else:
         # Non-session note
@@ -232,7 +247,7 @@ def obsidian_write_note(
         path = folder / filename
         path.write_text(_build_note(
             title=title, body=body, note_type=note_type,
-            agent=agent, session_stem=session_stem, created_at=created_at,
+            agent=agent, session_stem=session_stem, created_at=created_at, project=project,
         ))
 
         # Auto-link to session note
@@ -265,7 +280,8 @@ def _parse_note_metadata(path: Path) -> dict:
         (l.lstrip("# ").strip() for l in full_text.splitlines() if l.startswith("# ")),
         path.stem,
     )
-    return {"created_at": created_at, "type": note_type, "title": title}
+    project = fm.get("project", "")
+    return {"created_at": created_at, "type": note_type, "title": title, "project": project}
 
 
 def obsidian_regenerate_index(vault: Path) -> None:
@@ -299,7 +315,8 @@ 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
-        lines.append(f"- {display_dt} [[{stem}]] — {meta['type']}")
+        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")