agent-notes 2.24.0__tar.gz → 2.25.0__tar.gz

{agent_notes-2.24.0 → agent_notes-2.25.0}/PKG-INFO

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

@@ -0,0 +1 @@
+2.25.0

{agent_notes-2.24.0 → agent_notes-2.25.0}/agent_notes/cli.py

@@ -226,6 +226,12 @@ def main():
     p_install.add_argument("--copy", action="store_true", help="Copy instead of symlink (with --local)")
     p_install.add_argument("--reconfigure", action="store_true",
         help="Clear existing state for this scope and re-run the wizard")
+    p_install.add_argument("--profile", metavar="LABEL",
+        help="Profile label for multi-subscription setups (e.g. work, personal)")
+    p_install.add_argument("--folder", metavar="DIR",
+        help="Local folder name override (e.g. .claude-work)")
+    p_install.add_argument("--global-home", metavar="DIR", dest="global_home",
+        help="Global home directory override (e.g. ~/.claude-work)")
     
     # build
     subparsers.add_parser("build", help="Build agent configuration files from source")
@@ -234,6 +240,11 @@ def main():
     p_uninstall = subparsers.add_parser("uninstall", help="Remove installed components")
     p_uninstall.add_argument("--local", action="store_true", help="Remove from current project only")
     p_uninstall.add_argument("--global", action="store_true", dest="global_", help="Remove from global scope only")
+    profile_group = p_uninstall.add_mutually_exclusive_group()
+    profile_group.add_argument("--profile", metavar="LABEL",
+        help="Profile label to uninstall (e.g. work)")
+    profile_group.add_argument("--all-profiles", action="store_true",
+        help="Uninstall all profiles for the target scope")
     
     # doctor
     p_doctor = subparsers.add_parser("doctor", help="Check installation health")
@@ -267,6 +278,7 @@ def main():
     p_regen.add_argument("--scope", choices=["global", "local"], help="Install scope")
     p_regen.add_argument("--cli", help="Regenerate specific CLI only")
     p_regen.add_argument("--local", action="store_true", help="Use local scope")
+    p_regen.add_argument("--profile", metavar="LABEL", help="Profile label")
     
     # memory
     p_memory = subparsers.add_parser("memory", help="Manage agent memory")
@@ -279,7 +291,7 @@ def main():
 
     # hook
     p_hook = subparsers.add_parser("hook", help="Claude Code hook integrations")
-    p_hook.add_argument("subaction", choices=["memory-bridge"],
+    p_hook.add_argument("subaction", choices=["memory-bridge", "session-discover"],
         help="Hook to run")
 
     # cost-report
@@ -290,7 +302,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", "memory"],
+        choices=["wizard", "show", "role-model", "role-agent", "provider", "providers", "memory", "cost-report"],
         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)")
@@ -311,15 +323,24 @@ def main():
         from .commands.build import build
         build()
     elif args.command == "install":
-        if args.local or args.copy:
+        if args.local or args.copy or args.profile or args.folder or args.global_home:
             from .commands.install import install
-            install(local=args.local, copy=args.copy, reconfigure=args.reconfigure)
+            install(
+                local=args.local, copy=args.copy, reconfigure=args.reconfigure,
+                profile_label=args.profile or "",
+                folder=args.folder or "",
+                global_home=args.global_home or "",
+            )
         else:
             from .commands.wizard import interactive_install
             interactive_install()
     elif args.command == "uninstall":
+        all_profiles = getattr(args, 'all_profiles', False)
+        profile_label = getattr(args, 'profile', '') or ""
         from .commands.install import uninstall
-        uninstall(local=args.local, global_=args.global_)
+        uninstall(local=args.local, global_=args.global_,
+                  profile_label=profile_label,
+                  all_profiles=all_profiles)
     elif args.command == "doctor":
         from .commands.doctor import doctor
         doctor(local=args.local, fix=args.fix)
@@ -338,7 +359,8 @@ def main():
             set_role(args.role_name, args.model_id, cli=args.cli, scope=args.scope, local=args.local)
     elif args.command == "regenerate":
         from .commands.regenerate import regenerate
-        regenerate(scope=args.scope, cli=args.cli, local=args.local)
+        regenerate(scope=args.scope, cli=args.cli, local=args.local,
+                   profile_label=getattr(args, 'profile', '') or "")
     elif args.command == "memory":
         from .commands.memory import memory
         memory(args.action, args.name, getattr(args, "extra", None), description=getattr(args, "description", ""))

{agent_notes-2.24.0 → agent_notes-2.25.0}/agent_notes/commands/config.py

@@ -194,8 +194,13 @@ def show(state=None) -> None:
     else:
         mem_label = "Disabled"
 
+    from ..services.user_config import load_user_config
+    cost_report_enabled = load_user_config().get("cost_report_enabled", False)
+    cost_report_label = "enabled" if cost_report_enabled else "disabled"
+
     print("Current configuration:")
-    print(f"  Memory:   {mem_label}")
+    print(f"  Memory:      {mem_label}")
+    print(f"  Cost report: {cost_report_label}")
 
     # Scopes
     scopes = []
@@ -465,6 +470,17 @@ def interactive_config_memory() -> None:
     _wizard_memory(state, before)
 
 
+def cost_report_toggle(value: str) -> None:
+    """Enable or disable cost reporting in user config."""
+    from ..services.user_config import load_user_config, save_user_config
+    cfg = load_user_config()
+    cfg["cost_report_enabled"] = (value == "on")
+    save_user_config(cfg)
+    state_label = "enabled" if value == "on" else "disabled"
+    print(f"Cost reporting {state_label}.")
+    print("Run 'agent-notes regenerate' to update generated rules.")
+
+
 # ── Entry point ──────────────────────────────────────────────────────────────
 
 def config(action: str = "wizard", args: Optional[list] = None, cli_filter: Optional[str] = None) -> None:
@@ -497,7 +513,12 @@ def config(action: str = "wizard", args: Optional[list] = None, cli_filter: Opti
         _wizard_provider_status(args[0])
     elif action == "memory":
         interactive_config_memory()
+    elif action == "cost-report":
+        if len(args) != 1 or args[0] not in ("on", "off"):
+            print("Usage: agent-notes config cost-report <on|off>")
+            sys.exit(1)
+        cost_report_toggle(args[0])
     else:
         print(f"Unknown config action: {action}")
-        print("Actions: wizard, show, role-model, role-agent, providers, provider, memory")
+        print("Actions: wizard, show, role-model, role-agent, providers, provider, memory, cost-report")
         sys.exit(1)

{agent_notes-2.24.0 → agent_notes-2.25.0}/agent_notes/commands/doctor.py

@@ -1,5 +1,7 @@
 """Health check for agent-notes installation."""
 
+from pathlib import Path
+
 # Re-export for backward compatibility. New code should import from agent_notes.domain.
 from ..domain.diagnostics import Issue, FixAction  # noqa: F401
 
@@ -53,19 +55,33 @@ def _check_session_hook(scope: str, issues: list) -> None:
     except KeyError:
         return
 
-    settings_path, _context_file, hook_command = _session_hook_paths(claude_backend, scope)
-    if not has_hook(settings_path, "SessionStart", hook_command):
-        issues.append(Issue(
-            "missing_hook",
-            str(settings_path),
-            "SessionStart hook not found — run: agent-notes install to re-add the hook",
-        ))
+    from ..services.state_store import load_state, get_profiles_for_project
+    state = load_state()
 
+    # Check all profiles for the current project (local scope) or default (global)
+    backends_to_check = [claude_backend]
+    if state and scope == "local":
+        for _key, ss in get_profiles_for_project(state, Path.cwd()):
+            bs = ss.clis.get("claude")
+            if bs and bs.local_dir_override:
+                backends_to_check.append(claude_backend.with_local_dir(bs.local_dir_override))
+
+    for backend in backends_to_check:
+        settings_path, _context_file, hook_command = _session_hook_paths(backend, scope)
+        if not settings_path.exists():
+            continue
+        if not has_hook(settings_path, "SessionStart", hook_command):
+            issues.append(Issue(
+                "missing_hook",
+                str(settings_path),
+                "SessionStart hook not found — run: agent-notes install to re-add the hook",
+            ))
+
+    # Memory bridge check on the default backend only
+    settings_path, _, _ = _session_hook_paths(claude_backend, scope)
     from ..constants import Hooks
-    from ..services.state_store import load_state
-    state = load_state()
     if state and state.memory.backend in ("obsidian", "wiki"):
-        if not has_hook(settings_path, "SessionStart", Hooks.MEMORY_BRIDGE):
+        if settings_path.exists() and not has_hook(settings_path, "SessionStart", Hooks.MEMORY_BRIDGE):
             issues.append(Issue(
                 "missing_hook",
                 str(settings_path),
@@ -111,12 +127,31 @@ def diagnose(scope: str, fix: bool = False) -> bool:
     issues = []
     fix_actions = []
 
-    # Run checks
-    check_stale_files(scope, issues, fix_actions)
-    check_broken_symlinks(scope, issues, fix_actions)
-    check_shadowed_files(scope, issues, fix_actions)
-    check_missing_files(scope, issues, fix_actions)
-    check_content_drift(scope, issues, fix_actions)
+    from ..services.state_store import load_current_state, get_profiles_for_project
+    from ..services.state_store import label_from_key
+
+    # For local scope, run checks against each installed profile
+    if scope == "local":
+        state = load_current_state()
+        profiles = []
+        if state:
+            profiles = get_profiles_for_project(state, Path.cwd().resolve())
+        # Fall back to default profile if none recorded
+        if not profiles:
+            profiles = [("", None)]
+        for key, _ss in profiles:
+            label = label_from_key(key, Path.cwd())
+            check_stale_files(scope, issues, fix_actions, profile_label=label)
+            check_broken_symlinks(scope, issues, fix_actions, profile_label=label)
+            check_shadowed_files(scope, issues, fix_actions, profile_label=label)
+            check_missing_files(scope, issues, fix_actions, profile_label=label)
+            check_content_drift(scope, issues, fix_actions, profile_label=label)
+    else:
+        check_stale_files(scope, issues, fix_actions)
+        check_broken_symlinks(scope, issues, fix_actions)
+        check_shadowed_files(scope, issues, fix_actions)
+        check_missing_files(scope, issues, fix_actions)
+        check_content_drift(scope, issues, fix_actions)
 
     # Build freshness check (scope-independent)
     check_build_freshness(issues, fix_actions)
@@ -128,7 +163,6 @@ def diagnose(scope: str, fix: bool = False) -> bool:
     _check_session_hook(scope, issues)
 
     # Print role→model assignments
-    from ..services.state_store import load_current_state
     state = load_current_state()
     if state is not None:
         _check_role_models(state)

{agent_notes-2.24.0 → agent_notes-2.25.0}/agent_notes/commands/hook.py

@@ -7,6 +7,33 @@ def hook(subaction: str) -> None:
     """Handle hook subactions."""
     if subaction == "memory-bridge":
         _memory_bridge()
+    elif subaction == "session-discover":
+        _session_discover()
+
+
+def _session_discover() -> None:
+    """Discover all agent-notes profiles for the current project and emit combined context."""
+    try:
+        from ..services.state_store import load_state, get_profiles_for_project
+        from ..registries.cli_registry import load_registry
+
+        state = load_state()
+        if state is None:
+            return
+
+        registry = load_registry()
+        default_local_dirs = {b.name: b.local_dir for b in registry.all()}
+
+        for key, scope_state in get_profiles_for_project(state, Path.cwd()):
+            for cli_name, backend_state in scope_state.clis.items():
+                local_dir = backend_state.local_dir_override or default_local_dirs.get(cli_name, ".claude")
+                context_file = Path(local_dir) / "agent-notes-context.md"
+                if context_file.exists():
+                    label = scope_state.profile_label or "default"
+                    print(f"<!-- agent-notes profile: {label} -->")
+                    print(context_file.read_text(encoding="utf-8"))
+    except Exception:
+        return
 
 
 def _memory_bridge() -> None:

{agent_notes-2.24.0 → agent_notes-2.25.0}/agent_notes/commands/info.py

@@ -73,10 +73,30 @@ def show_info() -> None:
         else:
             print("  Global:   none")
 
+        # Named global profiles
+        if st.global_installs:
+            for label, gs in sorted(st.global_installs.items()):
+                print(f"  Global [{label}]: installed {gs.installed_at}, {gs.mode}")
+                if gs.clis:
+                    backend_summaries = []
+                    for backend_name, bs in sorted(gs.clis.items()):
+                        parts = []
+                        for component_type, items in bs.installed.items():
+                            if items:
+                                parts.append(f"{len(items)} {component_type}")
+                        if parts:
+                            extra = ""
+                            if bs.global_home_override:
+                                extra = f", home={bs.global_home_override}"
+                            backend_summaries.append(f"{backend_name} ({', '.join(parts)}{extra})")
+                    if backend_summaries:
+                        print(f"            Storage: {', '.join(backend_summaries)}")
+
         # Local installs
         if st.local_installs:
             for project_path, ls in sorted(st.local_installs.items()):
-                print(f"  Local:    {project_path}  (installed {ls.installed_at}, {ls.mode})")
+                profile_hint = f" [{ls.profile_label}]" if ls.profile_label else ""
+                print(f"  Local{profile_hint}:  {project_path}  (installed {ls.installed_at}, {ls.mode})")
                 if ls.clis:
                     backend_summaries = []
                     for backend_name, bs in sorted(ls.clis.items()):
@@ -85,7 +105,10 @@ def show_info() -> None:
                             if items:
                                 counts.append(f"{len(items)} {component_type}")
                         if counts:
-                            backend_summaries.append(f"{backend_name} ({', '.join(counts)})")
+                            extra = ""
+                            if bs.local_dir_override:
+                                extra = f", folder={bs.local_dir_override}"
+                            backend_summaries.append(f"{backend_name} ({', '.join(counts)}{extra})")
                     if backend_summaries:
                         print(f"            Storage: {', '.join(backend_summaries)}")
         else:

agent_notes-2.25.0/agent_notes/commands/install.py

@@ -0,0 +1,225 @@
+"""Install command."""
+
+from pathlib import Path
+
+from ..config import Color, PKG_DIR
+from ..services.install_state_builder import build_install_state
+from ..services.state_store import load_current_state, record_install_state, remove_install_state, label_from_key
+from ._install_helpers import _verify_install
+
+
+def install(local: bool = False, copy: bool = False, reconfigure: bool = False,
+            profile_label: str = "", folder: str = "", global_home: str = "") -> None:
+    """Build from source and install to targets."""
+    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
+
+    # Build folder overrides from --folder / --profile
+    folder_overrides = None
+    if folder:
+        folder_overrides = {"claude": folder}
+    elif profile_label and not folder:
+        folder_overrides = {"claude": f".claude-{profile_label}"}
+
+    # Default --global-home from profile label if not explicit
+    if profile_label and not global_home:
+        global_home = f"~/.claude-{profile_label}"
+
+    state = load_current_state()
+    existing = get_scope(state, scope, project_path, profile_label=profile_label) if state else None
+
+    profile_hint = f" (profile: {profile_label})" if profile_label else ""
+
+    if existing and not reconfigure:
+        # Print existing-install summary
+        print(f"Found existing {scope} installation{profile_hint} at {state_file()}")
+        print(f"  Installed: {existing.installed_at}")
+        cli_labels = []
+        from ..registries.cli_registry import load_registry
+        registry = load_registry()
+        for cli_name in existing.clis.keys():
+            try:
+                cli_labels.append(registry.get(cli_name).label)
+            except KeyError:
+                cli_labels.append(cli_name)
+        print(f"  CLIs:      {', '.join(cli_labels)}")
+        print(f"  Mode:      {existing.mode}")
+        print()
+        print("Verifying ...")
+        issues = _verify_install(existing, scope, project_path, registry)
+        if not issues:
+            print()
+            print("Installation is healthy.")
+            print()
+            print("Tip: To reinstall with different choices, run:")
+            print("       agent-notes uninstall")
+            print("       agent-notes install")
+            print()
+            print("     Or to re-run the wizard and overwrite in place:")
+            print("       agent-notes install --reconfigure")
+        else:
+            print()
+            print(f"Installation has {len(issues)} issue(s).")
+            print()
+            print("Tip: Run `agent-notes doctor --fix` to repair, or `agent-notes install --reconfigure` to rewizard.")
+        return
+
+    if existing and reconfigure:
+        print(f"Clearing existing {scope} state{profile_hint} (--reconfigure) ...")
+        remove_install_state(scope, project_path, profile_label=profile_label)
+        # Fall through to normal install flow
+
+    # Validate args
+    if copy and not local:
+        print("Error: --copy is only valid with --local installs.")
+        print("Global installs always use symlinks.")
+        return
+
+    # Build first
+    print("Building from source...")
+    try:
+        from ..commands.build import build
+        build()
+    except Exception as e:
+        print(f"{Color.RED}Build failed: {e}{Color.NC}")
+        return
+
+    # Execute
+    label_msg = f", profile={profile_label}" if profile_label else ""
+    print(f"Installing ({'local' if local else 'global'}, {'copy' if copy else 'symlink'}{label_msg}) ...")
+    print("")
+
+    from ..services import installer
+    scope = "local" if local else "global"
+    copy_mode = copy
+    installer.install_all(scope, copy_mode,
+                          folder_overrides=folder_overrides,
+                          global_home_override=global_home or None)
+
+    print("")
+    print(f"{Color.GREEN}Done.{Color.NC} Restart Claude Code / OpenCode to pick up changes.")
+
+    # Record state
+    try:
+        project_path = Path.cwd() if local else None
+        st = build_install_state(
+            mode="copy" if copy else "symlink",
+            scope="local" if local else "global",
+            repo_root=PKG_DIR.parent,
+            project_path=project_path,
+            profile_label=profile_label,
+            folder_overrides=folder_overrides,
+            global_home_override=global_home or None,
+        )
+        record_install_state(st)
+    except Exception as e:
+        print(f"{Color.YELLOW}Warning: failed to write state.json: {e}{Color.NC}")
+
+
+def _resolve_overrides_from_state(scope: str, project_path, profile_label: str = ""):
+    """Read folder/global_home overrides from state.json for the target scope."""
+    from ..services.state_store import load_state, get_scope
+
+    folder_overrides = None
+    global_home_override = None
+
+    state = load_state()
+    if state is None:
+        return folder_overrides, global_home_override
+
+    ss = get_scope(state, scope, project_path, profile_label=profile_label)
+    if ss is None:
+        return folder_overrides, global_home_override
+
+    for cli_name, bs in ss.clis.items():
+        if bs.local_dir_override:
+            folder_overrides = folder_overrides or {}
+            folder_overrides[cli_name] = bs.local_dir_override
+        if bs.global_home_override:
+            global_home_override = bs.global_home_override
+
+    return folder_overrides, global_home_override
+
+
+def uninstall(local: bool = False, global_: bool = False,
+              profile_label: str = "", all_profiles: bool = False) -> None:
+    """Remove installed components managed by agent-notes."""
+    from ..services import installer
+    from ..services.state_store import load_state, get_profiles_for_project
+
+    # Determine which scopes to uninstall
+    if local and not global_:
+        scopes = [("local", Path.cwd().resolve())]
+    elif global_ and not local:
+        scopes = [("global", None)]
+    else:
+        scopes = [("global", None), ("local", Path.cwd().resolve())]
+
+    if all_profiles:
+        state = load_state()
+        if state is None:
+            print("Nothing to uninstall — no agent-notes state found.")
+            return
+        for scope, project_path in scopes:
+            if scope == "local":
+                profiles = get_profiles_for_project(state, project_path) if state else []
+                if not profiles:
+                    print(f"  No profiles found for {project_path}")
+                    continue
+                for key, _ss in profiles:
+                    label = label_from_key(key, project_path)
+                    folder_overrides, global_home_override = _resolve_overrides_from_state(
+                        scope, project_path, label)
+                    label_hint = f" profile={label}" if label else ""
+                    print(f"Uninstalling agent-notes ({scope}{label_hint}) ...")
+                    installer.uninstall_all(scope,
+                                            folder_overrides=folder_overrides,
+                                            global_home_override=global_home_override,
+                                            profile_label=label)
+                    try:
+                        remove_install_state(scope, project_path, profile_label=label)
+                    except Exception as e:
+                        print(f"{Color.YELLOW}Warning: failed to clear state.json: {e}{Color.NC}")
+            else:
+                # Global: uninstall default + all labeled profiles
+                global_labels = [""] if (state and state.global_install) else []
+                if state:
+                    global_labels += list(state.global_installs.keys())
+                for label in global_labels:
+                    folder_overrides, global_home_override = _resolve_overrides_from_state(
+                        scope, None, label)
+                    label_hint = f" profile={label}" if label else ""
+                    print(f"Uninstalling agent-notes ({scope}{label_hint}) ...")
+                    installer.uninstall_all(scope,
+                                            folder_overrides=folder_overrides,
+                                            global_home_override=global_home_override,
+                                            profile_label=label)
+                    try:
+                        remove_install_state(scope, None, profile_label=label)
+                    except Exception as e:
+                        print(f"{Color.YELLOW}Warning: failed to clear state.json: {e}{Color.NC}")
+        print(f"{Color.GREEN}Done.{Color.NC} agent-notes components removed.")
+        return
+
+    for scope, project_path in scopes:
+        # Always resolve overrides from state so we clean the right directories
+        folder_overrides, global_home_override = _resolve_overrides_from_state(
+            scope, project_path, profile_label)
+
+        label_hint = f" profile={profile_label}" if profile_label else ""
+        print(f"Uninstalling agent-notes ({scope}{label_hint}) ...")
+        installer.uninstall_all(scope,
+                                folder_overrides=folder_overrides,
+                                global_home_override=global_home_override,
+                                profile_label=profile_label)
+
+        # Remove state entry for this scope
+        try:
+            remove_install_state(scope, project_path, profile_label=profile_label)
+        except Exception as e:
+            print(f"{Color.YELLOW}Warning: failed to clear state.json: {e}{Color.NC}")
+
+    print(f"{Color.GREEN}Done.{Color.NC} agent-notes components removed.")