agent-notes 2.22.0__tar.gz → 2.23.0__tar.gz

{agent_notes-2.22.0 → agent_notes-2.23.0}/PKG-INFO

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

@@ -0,0 +1 @@
+2.23.0

{agent_notes-2.22.0 → agent_notes-2.23.0}/agent_notes/cli.py

@@ -284,7 +284,7 @@ def main():
     # config
     p_config = subparsers.add_parser("config", help="Reconfigure role/agent/model/memory/skill assignments after install")
     p_config.add_argument("action", nargs="?", default="wizard",
-        choices=["wizard", "show", "role-model", "role-agent", "provider", "providers"],
+        choices=["wizard", "show", "role-model", "role-agent", "provider", "providers", "memory"],
         help="Config action (default: wizard)")
     p_config.add_argument("extra", nargs="*", help="Additional positional args (role, model, agent)")
     p_config.add_argument("--cli", help="Target CLI (claude / opencode / both)")

{agent_notes-2.22.0 → agent_notes-2.23.0}/agent_notes/commands/build.py

@@ -91,18 +91,18 @@ def count_lines(file_path: Path) -> int:
 
 def build() -> None:
     """Build agent configuration files from source."""
-    from .. import state as state_module
+    from ..services.state_store import load_state
     from ..config import ROOT
-    
+
     # Read configuration
     try:
         agents_config, tiers = load_agents_config()
     except FileNotFoundError as e:
         print(f"Error: {e}")
         return
-    
+
     # Load state if present (no error if missing)
-    state = state_module.load()
+    state = load_state()
     
     # Generate agent files (state=None is backward compatible)
     print("Generating agent files...")

{agent_notes-2.22.0 → agent_notes-2.23.0}/agent_notes/commands/config.py

@@ -7,11 +7,13 @@ import sys
 from pathlib import Path
 from typing import Optional
 
+from ..constants import DEFAULT_VAULT_DIR, DEFAULT_VAULT_NAME, Wiki, Obsidian
+
 
 def _load_state():
     """Load state or exit with a clear message."""
-    from .. import state as state_mod
-    st = state_mod.load()
+    from ..services.state_store import load_state
+    st = load_state()
     if st is None:
         print("No installation found. Run `agent-notes install` first.")
         sys.exit(1)
@@ -95,7 +97,7 @@ def _print_diff(before: str, after: str) -> None:
 
 def _apply_and_regenerate(state, before: str) -> None:
     """Show diff, prompt, then write + regenerate on Y."""
-    from .. import install_state
+    from ..services.state_store import record_install_state
     from ..config import Color
     from ..services.ui import _safe_input
 
@@ -114,7 +116,7 @@ def _apply_and_regenerate(state, before: str) -> None:
         print("Discarded. No changes written.")
         return
 
-    install_state.record_install_state(state)
+    record_install_state(state)
     print("State written.")
 
     # Regenerate
@@ -311,9 +313,9 @@ def _wizard_memory(state, before: str) -> bool:
     from ..services.ui import _safe_input, _path_input
 
     storage_options = {
-        "1": ("local", "Local markdown files (~/.claude/agent-memory/)"),
+        "1": ("local", "Local files"),
         "2": ("obsidian", "Obsidian vault"),
-        "3": ("none", "None (disable memory)"),
+        "3": ("none", "Disabled"),
     }
 
     print("\nMemory storage options:")
@@ -329,7 +331,10 @@ def _wizard_memory(state, before: str) -> bool:
     path = ""
 
     if backend == "obsidian":
-        mode_options = {"1": ("obsidian", "Session-oriented"), "2": ("wiki", "Wiki")}
+        mode_options = {
+            "1": ("obsidian", "Session notes — project-scoped decisions, patterns, mistakes"),
+            "2": ("wiki", "Knowledge wiki — Karpathy compile-once pattern with concepts, entities, sources"),
+        }
         print("\n  Obsidian mode:")
         for key, (_, mlabel) in mode_options.items():
             print(f"    {key}) {mlabel}")
@@ -337,8 +342,8 @@ def _wizard_memory(state, before: str) -> bool:
         if mode_choice in mode_options:
             backend, label = mode_options[mode_choice]
 
-        subfolder = "notes" if backend == "obsidian" else "knowledge"
-        default_vault = str(Path.home() / "Documents" / "Obsidian Vault")
+        subfolder = Obsidian.SUBFOLDER if backend == "obsidian" else Wiki.SUBFOLDER
+        default_vault = str(Path.home() / DEFAULT_VAULT_DIR / DEFAULT_VAULT_NAME)
         print(f"  Folder name: {subfolder}")
         print("  Press Tab to autocomplete paths")
         raw = _path_input(f"  Vault path [{default_vault}]: ", default_vault).strip()
@@ -453,6 +458,13 @@ def interactive_config() -> None:
         print(f"Unknown choice '{choice}'. Quit.")
 
 
+def interactive_config_memory() -> None:
+    """Run the interactive memory config wizard."""
+    state = _load_state()
+    before = _state_snapshot(state)
+    _wizard_memory(state, before)
+
+
 # ── Entry point ──────────────────────────────────────────────────────────────
 
 def config(action: str = "wizard", args: Optional[list] = None, cli_filter: Optional[str] = None) -> None:
@@ -483,7 +495,9 @@ def config(action: str = "wizard", args: Optional[list] = None, cli_filter: Opti
             print("Usage: agent-notes config provider <name>")
             sys.exit(1)
         _wizard_provider_status(args[0])
+    elif action == "memory":
+        interactive_config_memory()
     else:
         print(f"Unknown config action: {action}")
-        print("Actions: wizard, show, role-model, role-agent, providers, provider")
+        print("Actions: wizard, show, role-model, role-agent, providers, provider, memory")
         sys.exit(1)

{agent_notes-2.22.0 → agent_notes-2.23.0}/agent_notes/commands/doctor.py

@@ -64,13 +64,12 @@ def _check_session_hook(scope: str, issues: list) -> None:
 
 def check_version_drift(scope: str, issues: list, fix_actions: list) -> None:
     """Check if the installed package version matches the current running version."""
-    from .. import install_state
+    from ..services.state_store import load_current_state, get_scope
     from ..config import get_version
     from ..domain.diagnostics import Issue, FixAction
-    from ..services.state_store import get_scope
     from pathlib import Path
 
-    state = install_state.load_current_state()
+    state = load_current_state()
     if state is None:
         return
 
@@ -96,8 +95,6 @@ def check_version_drift(scope: str, issues: list, fix_actions: list) -> None:
 
 def diagnose(scope: str, fix: bool = False) -> bool:
     """Run all diagnostic checks and optionally apply fixes."""
-    from .. import install_state
-
     print_summary(scope)
 
     issues = []
@@ -120,7 +117,8 @@ def diagnose(scope: str, fix: bool = False) -> bool:
     _check_session_hook(scope, issues)
 
     # Print role→model assignments
-    state = install_state.load_current_state()
+    from ..services.state_store import load_current_state
+    state = load_current_state()
     if state is not None:
         _check_role_models(state)
     

{agent_notes-2.22.0 → agent_notes-2.23.0}/agent_notes/commands/info.py

@@ -2,7 +2,7 @@
 
 from pathlib import Path
 
-from .. import install_state
+from ..services.state_store import load_current_state as _load_current_state
 from ..config import get_version, CLAUDE_HOME, Color
 from ._install_helpers import count_skills, count_agents, count_global
 
@@ -49,7 +49,7 @@ def show_info() -> None:
         print(f"  Local:   {Color.CYAN}not detected{Color.NC}")
     
     # State info
-    st = install_state.load_current_state()
+    st = _load_current_state()
     if st is not None:
         print("")
         print("Last install:")

{agent_notes-2.22.0 → agent_notes-2.23.0}/agent_notes/commands/install.py

@@ -3,19 +3,20 @@
 from pathlib import Path
 
 from ..config import Color, PKG_DIR
-from .. import install_state
+from ..services.install_state_builder import build_install_state
+from ..services.state_store import load_current_state, record_install_state, remove_install_state
 from ._install_helpers import _verify_install
 
 
 def install(local: bool = False, copy: bool = False, reconfigure: bool = False) -> None:
     """Build from source and install to targets."""
-    from ..state import get_scope, state_file
+    from ..services.state_store import get_scope, state_file
     from pathlib import Path
-    
+
     scope = "local" if local else "global"
     project_path = Path.cwd().resolve() if local else None
 
-    state = install_state.load_current_state()
+    state = load_current_state()
     existing = get_scope(state, scope, project_path) if state else None
 
     if existing and not reconfigure:
@@ -55,7 +56,7 @@ def install(local: bool = False, copy: bool = False, reconfigure: bool = False)
 
     if existing and reconfigure:
         print(f"Clearing existing {scope} state (--reconfigure) ...")
-        install_state.remove_install_state(scope, project_path)
+        remove_install_state(scope, project_path)
         # Fall through to normal install flow
     
     # Validate args
@@ -88,13 +89,13 @@ def install(local: bool = False, copy: bool = False, reconfigure: bool = False)
     # Record state
     try:
         project_path = Path.cwd() if local else None
-        st = install_state.build_install_state(
+        st = build_install_state(
             mode="copy" if copy else "symlink",
             scope="local" if local else "global",
             repo_root=PKG_DIR.parent,  # repo root (parent of agent_notes pkg)
             project_path=project_path,
         )
-        install_state.record_install_state(st)
+        record_install_state(st)
     except Exception as e:
         print(f"{Color.YELLOW}Warning: failed to write state.json: {e}{Color.NC}")
 
@@ -117,7 +118,7 @@ def uninstall(local: bool = False, global_: bool = False) -> None:
 
         # Remove state entry for this scope
         try:
-            install_state.remove_install_state(scope, project_path)
+            remove_install_state(scope, project_path)
         except Exception as e:
             print(f"{Color.YELLOW}Warning: failed to clear state.json: {e}{Color.NC}")
 

agent_notes-2.23.0/agent_notes/commands/memory/__init__.py

@@ -0,0 +1,107 @@
+"""Manage agent memory stored in ~/.claude/agent-memory/."""
+
+from typing import Optional
+
+from . import _common
+from ._common import _load_memory_config, get_directory_size, format_size, _WIKI_TYPE_MAP
+from .vault import do_vault, do_init, do_index
+from .notes import do_add, do_list, do_show, do_size
+from .transfer import do_export, do_import
+from .wiki import do_ingest, do_query, do_lint, do_scan_raw
+from .migrate import do_migrate
+from .reset import do_reset
+
+
+def show_help() -> None:
+    """Show memory command help."""
+    help_text = """Usage: agent-notes memory [command] [args]
+
+Manage agent memory.
+
+Commands:
+  init             Create folder structure and Index.md
+  list             List all agent memories with sizes (default)
+  vault            Show current backend and memory path
+  index            Regenerate Index.md for the current backend
+  add <title> <body>  Add a note (obsidian and wiki backends)
+  migrate          Migrate old per-project layout to new shared flat layout
+  size             Total disk usage
+  show <name>      Show memory contents for one agent/category
+  reset            Clear ALL memories (requires confirmation)
+  reset <name>     Clear one agent's memory
+  export           Back up memories to agent-notes/memory-backup/
+  import           Restore from agent-notes/memory-backup/
+  ingest <title> <body>  Ingest source material and fan-out to concepts/entities (wiki backend)
+  query <keyword>  Search wiki pages by keyword (wiki backend)
+  lint             Check wiki health: orphans, broken links, stale index (wiki backend)
+
+Examples:
+  agent-notes memory                    List all memories
+  agent-notes memory vault              Show backend configuration
+  agent-notes memory index              Regenerate Index.md
+  agent-notes memory migrate            Migrate to new flat layout
+  agent-notes memory show coder         View coder agent's memory
+  agent-notes memory reset reviewer     Clear reviewer's memory
+  agent-notes memory export             Back up before cleanup"""
+
+    print(help_text)
+
+
+def memory(action: str = "list", name: Optional[str] = None, extra: Optional[list] = None) -> None:
+    """Manage agent memory."""
+    if action == "list":
+        do_list()
+    elif action == "init":
+        do_init()
+    elif action == "vault":
+        do_vault()
+    elif action == "index":
+        do_index()
+    elif action == "add":
+        # name is title, extra[0] is body
+        if not name:
+            print("Error: add requires a title.")
+            exit(1)
+        body = extra[0] if extra else ""
+        note_type = extra[1] if extra and len(extra) > 1 else "context"
+        agent = extra[2] if extra and len(extra) > 2 else ""
+        project = extra[3] if extra and len(extra) > 3 else ""
+        do_add(name, body, note_type=note_type, agent=agent, project=project)
+    elif action == "size":
+        do_size()
+    elif action == "show":
+        if not name:
+            print("Error: show requires an agent name.")
+            exit(1)
+        do_show(name)
+    elif action == "reset":
+        do_reset(name)
+    elif action == "export":
+        do_export()
+    elif action == "import":
+        do_import()
+    elif action == "migrate":
+        do_migrate()
+    elif action == "ingest":
+        if not name:
+            do_scan_raw()
+            exit(0)
+        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()
+        exit(1)

agent_notes-2.23.0/agent_notes/commands/memory/_common.py

@@ -0,0 +1,63 @@
+"""Shared helpers for memory subcommands."""
+
+from pathlib import Path
+from typing import Optional
+
+from ...config import MEMORY_DIR
+
+
+_WIKI_TYPE_MAP = {
+    "pattern": "concepts",
+    "decision": "concepts",
+    "mistake": "concepts",
+    "context": "concepts",
+    "concept": "concepts",
+    "concepts": "concepts",
+    "entity": "entities",
+    "entities": "entities",
+    "synthesis": "synthesis",
+    "session": "sessions",
+    "sessions": "sessions",
+    "source": "sources",
+    "sources": "sources",
+}
+
+
+def _load_memory_config():
+    from ...services.state_store import load_state
+    from ...config import memory_dir_for_backend
+    state = load_state()
+    if state is None:
+        return "local", MEMORY_DIR
+    backend = state.memory.backend
+    path = memory_dir_for_backend(backend, state.memory.path)
+    return backend, path
+
+
+def get_directory_size(path: Path) -> int:
+    """Calculate total size of directory in bytes."""
+    total = 0
+    try:
+        for item in path.rglob('*'):
+            if item.is_file():
+                total += item.stat().st_size
+    except (OSError, PermissionError):
+        pass
+    return total
+
+
+def format_size(size_bytes: int) -> str:
+    """Format size in human-readable format."""
+    if size_bytes == 0:
+        return "0B"
+
+    original_size = size_bytes
+    for unit in ['B', 'K', 'M', 'G', 'T']:
+        if original_size < 1024:
+            if unit == 'B':
+                return f"{original_size}B"
+            else:
+                return f"{original_size:.1f}{unit}"
+        original_size /= 1024
+
+    return f"{original_size:.1f}P"

agent_notes-2.23.0/agent_notes/commands/memory/migrate.py

@@ -0,0 +1,152 @@
+"""Migration subcommand: migrate."""
+
+import re
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+from . import _common
+from ...config import Color
+
+
+def do_migrate() -> None:
+    """Migrate vault from per-project layout to flat shared layout with new filenames."""
+    backend, vault = _common._load_memory_config()
+    if backend != "obsidian":
+        print("migrate is only available for obsidian storage.")
+        return
+    if vault is None:
+        print("Memory path not configured.")
+        return
+
+    from ...services.obsidian_backend import OBSIDIAN_CATEGORIES
+    from ...services.memory_router import memory_regenerate_index
+    from ...services._memory_utils import _parse_frontmatter
+
+    _NEW_FILE_RE = re.compile(r"^\d{4}-\d{2}-\d{2}_")
+    _LEGACY_TS_RE = re.compile(r"^(\d{4})-(\d{2})-(\d{2})-(\d{2})-(\d{2})-(\d{2})-(.+)$")
+    _BARE_UUID_RE = re.compile(
+        r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.IGNORECASE
+    )
+
+    moved = 0
+    renamed = 0
+    skipped = 0
+    errors: list[str] = []
+
+    def _date_from_frontmatter(path: Path) -> Optional[str]:
+        try:
+            text = path.read_text()
+            fm, _ = _parse_frontmatter(text)
+            ca = fm.get("created_at", "")
+            if re.fullmatch(r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z", ca):
+                return ca[:10]
+        except OSError:
+            pass
+        return None
+
+    def _date_from_mtime(path: Path) -> str:
+        ts = path.stat().st_mtime
+        return datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%d")
+
+    def _safe_rename(src: Path, dst: Path) -> bool:
+        if dst.exists():
+            return False
+        src.rename(dst)
+        return True
+
+    def _new_stem(old_stem: str, folder: Path, path: Path) -> Optional[str]:
+        """Return new stem under new naming scheme, or None if already correct."""
+        if _NEW_FILE_RE.match(old_stem):
+            return None  # already in new format
+
+        # Legacy timestamp: YYYY-MM-DD-HH-MM-SS-<slug>
+        m = _LEGACY_TS_RE.match(old_stem)
+        if m:
+            date_part = f"{m.group(1)}-{m.group(2)}-{m.group(3)}"
+            slug_part = m.group(7)
+            base = f"{date_part}_{slug_part}"
+            candidate = f"{base}.md"
+            if not (folder / candidate).exists():
+                return base
+            # collision: append HHMMSS from the original timestamp
+            hhmmss = f"{m.group(4)}{m.group(5)}{m.group(6)}"
+            return f"{base}_{hhmmss}"
+
+        # Bare session UUID: <uuid>.md → <date>_<uuid>.md
+        if _BARE_UUID_RE.match(old_stem):
+            date_part = _date_from_frontmatter(path) or _date_from_mtime(path)
+            base = f"{date_part}_{old_stem}"
+            candidate = f"{base}.md"
+            if not (folder / candidate).exists():
+                return base
+            hhmmss = datetime.fromtimestamp(path.stat().st_mtime, tz=timezone.utc).strftime("%H%M%S")
+            return f"{base}_{hhmmss}"
+
+        # Unrecognized pattern — skip
+        return None
+
+    # Step 1: move files from per-project subfolders into the shared root
+    for item in list(vault.iterdir()):
+        if not item.is_dir():
+            continue
+        if item.name in OBSIDIAN_CATEGORIES or item.name == "Index.md":
+            continue
+        # item is a per-project subfolder
+        for cat in OBSIDIAN_CATEGORIES:
+            src_cat = item / cat
+            if not src_cat.exists():
+                continue
+            dst_cat = vault / cat
+            dst_cat.mkdir(exist_ok=True)
+            for note in src_cat.glob("*.md"):
+                dst = dst_cat / note.name
+                if dst.exists():
+                    errors.append(f"collision: {note} -> {dst}")
+                    continue
+                try:
+                    shutil.move(str(note), str(dst))
+                    moved += 1
+                except OSError as exc:
+                    errors.append(f"move failed: {note}: {exc}")
+            # Remove now-empty category subdir so parent rmdir can succeed
+            try:
+                src_cat.rmdir()
+            except OSError:
+                pass
+        # Remove subfolder only if empty (preserves any uncategorized files the user may have there)
+        try:
+            item.rmdir()
+        except OSError:
+            errors.append(f"per-project subfolder not removed (non-empty): {item}")
+
+    # Step 2: rename files in each category to the new naming scheme
+    for cat in OBSIDIAN_CATEGORIES:
+        cat_dir = vault / cat
+        if not cat_dir.exists():
+            continue
+        for note in list(cat_dir.glob("*.md")):
+            new_stem = _new_stem(note.stem, cat_dir, note)
+            if new_stem is None:
+                skipped += 1
+                continue
+            dst = cat_dir / f"{new_stem}.md"
+            try:
+                if not _safe_rename(note, dst):
+                    errors.append(f"rename collision: {note.name} -> {dst.name}")
+                    skipped += 1
+                else:
+                    renamed += 1
+            except OSError as exc:
+                errors.append(f"rename failed: {note}: {exc}")
+                skipped += 1
+
+    # Step 3: regenerate index
+    memory_regenerate_index(backend, vault)
+
+    print(f"{moved} moved, {renamed} renamed, {skipped} skipped", end="")
+    if errors:
+        print(f", errors: {'; '.join(errors)}")
+    else:
+        print()