agent-diary 4.3.0__py3-none-any.whl

agent_diary-4.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+claude_diary

claude_diary/__init__.py

@@ -0,0 +1,3 @@
+"""Claude Code Working Diary — Auto-generate work diaries from Claude Code sessions."""
+
+__version__ = "4.3.0"

claude_diary/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as: python -m claude_diary"""
+from claude_diary.cli import main
+
+if __name__ == "__main__":
+    main()

claude_diary/cli/__init__.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python
+"""claude-diary CLI — search, filter, stats, and manage your work diary."""
+
+import argparse
+import sys
+
+# Re-export dependencies so submodules can access them via claude_diary.cli.*
+# and so that tests can patch them at claude_diary.cli.<name>.
+from claude_diary.config import load_config, save_config, get_config_path, migrate_from_env
+from claude_diary.i18n import get_label
+from claude_diary.indexer import load_index
+from claude_diary.lib.stats import parse_daily_file
+from claude_diary.writer import ensure_diary_dir
+
+# Import command functions from submodules
+from claude_diary.cli.search import cmd_search, cmd_filter, cmd_trace, _fallback_search_from_files
+from claude_diary.cli.stats import cmd_stats, cmd_weekly, _get_terminal_width, _print_box_top, _print_box_bottom
+from claude_diary.cli.config import cmd_config, cmd_init, cmd_migrate, _add_exporter_interactive
+from claude_diary.cli.team import cmd_team
+from claude_diary.cli.maintenance import cmd_reindex, cmd_audit, cmd_delete, cmd_dashboard
+from claude_diary.cli.setup import cmd_install, cmd_uninstall
+from claude_diary.cli.write import cmd_write
+from claude_diary.cli.notion_push import cmd_notion_push
+from claude_diary.cli.notion_init import cmd_notion_init
+from claude_diary.cli.notion_ensure import cmd_notion_ensure
+from claude_diary.cli.notion_ops import cmd_notion_ops
+from claude_diary.cli.notion_review import cmd_notion_review
+
+
+def cmd_notion(args):
+    """Dispatch `diary-notion|notion <action>` to the right command."""
+    if args.action == "push":
+        cmd_notion_push(args)
+    elif args.action == "init":
+        cmd_notion_init(args)
+    elif args.action == "ensure":
+        cmd_notion_ensure(args)
+    elif args.action == "ops":
+        cmd_notion_ops(args)
+    elif args.action == "review":
+        cmd_notion_review(args)
+
+
+def _add_diary_notion_parser(sub, name):
+    p_notion = sub.add_parser(name, help="Notion hierarchical work diary integration")
+    p_notion.add_argument("action", choices=["init", "push", "ensure", "ops", "review"],
+                          help="Action to perform")
+    p_notion.add_argument("--input", help="JSON input file (push only)")
+    p_notion.add_argument("--force", action="store_true",
+                          help="Archive prior rows for the session before pushing (push only)")
+    p_notion.add_argument("--year", type=int, help="Target year (ensure/ops/review only)")
+    p_notion.add_argument("--apply", action="store_true",
+                          help="Mark the listed rows reviewed (review only)")
+    p_notion.add_argument("--dry-run", action="store_true",
+                          help="Preview push body without writing, or print ensure plan")
+    p_notion.add_argument("--preview-file",
+                          help="Write push dry-run/preview Markdown to this file")
+    p_notion.add_argument("--artifact-dir", default=".codefleet/runs",
+                          help="Directory for local run artifacts (push only)")
+    p_notion.add_argument("--no-artifacts", action="store_true",
+                          help="Do not write local run artifacts (push only)")
+    p_notion.add_argument("--stale-days", type=int, default=7,
+                          help="Mark active rows stale after N days (ops only)")
+    p_notion.add_argument("--json", dest="json_output", action="store_true",
+                          help="Output operations report as JSON (ops only)")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="claude-diary",
+        description="Auto-generated work diary from Claude Code sessions",
+    )
+    from claude_diary import __version__
+    parser.add_argument("--version", action="version", version="claude-diary %s" % __version__)
+
+    sub = parser.add_subparsers(dest="command")
+
+    # search
+    p_search = sub.add_parser("search", help="Search diary entries by keyword")
+    p_search.add_argument("keyword", help="Keyword to search")
+    p_search.add_argument("--project", "-p", help="Filter by project")
+    p_search.add_argument("--category", "-c", help="Filter by category")
+    p_search.add_argument("--from", dest="date_from", help="Start date (YYYY-MM-DD)")
+    p_search.add_argument("--to", dest="date_to", help="End date (YYYY-MM-DD)")
+    p_search.add_argument("--json", dest="json_output", action="store_true", help="Output as JSON")
+
+    # filter
+    p_filter = sub.add_parser("filter", help="Filter diary entries")
+    p_filter.add_argument("--project", "-p", help="Filter by project")
+    p_filter.add_argument("--category", "-c", help="Filter by category")
+    p_filter.add_argument("--month", "-m", help="Filter by month (YYYY-MM)")
+    p_filter.add_argument("--json", dest="json_output", action="store_true", help="Output as JSON")
+
+    # trace
+    p_trace = sub.add_parser("trace", help="Trace file change history")
+    p_trace.add_argument("filepath", help="File path or glob pattern to trace")
+    p_trace.add_argument("--project", "-p", help="Filter by project")
+
+    # stats
+    p_stats = sub.add_parser("stats", help="Show terminal dashboard")
+    p_stats.add_argument("--month", "-m", help="Month (YYYY-MM)")
+    p_stats.add_argument("--project", "-p", help="Filter by project")
+
+    # weekly
+    p_weekly = sub.add_parser("weekly", help="Generate weekly summary")
+    p_weekly.add_argument("date", nargs="?", help="Any date in target week (YYYY-MM-DD)")
+
+    # config
+    p_config = sub.add_parser("config", help="View or update configuration")
+    p_config.add_argument("--set", dest="set_value", help="Set config (key=value)")
+    p_config.add_argument("--add-exporter", help="Add exporter (interactive)")
+
+    # init
+    p_init = sub.add_parser("init", help="Initialize agent-diary setup")
+    init_mode = p_init.add_mutually_exclusive_group()
+    init_mode.add_argument("--team", dest="team_repo", help="Team repo URL for team mode")
+    init_mode.add_argument("--codex-only", action="store_true",
+                           help="Initialize config/diary directories without registering Claude Code hooks")
+
+    # migrate
+    sub.add_parser("migrate", help="Migrate v1.0 env vars to config.json")
+
+    # team
+    p_team = sub.add_parser("team", help="Team management commands")
+    p_team.add_argument("action", nargs="?", default="stats",
+                        choices=["stats", "weekly", "monthly", "init", "add-member"],
+                        help="Team action")
+    p_team.add_argument("--project", "-p", help="Filter by project")
+    p_team.add_argument("--member", help="Filter by member")
+    p_team.add_argument("--month", "-m", help="Month (YYYY-MM)")
+    p_team.add_argument("--repo", help="Team repo URL (for init)")
+    p_team.add_argument("--name", help="Member name (for init/add-member)")
+    p_team.add_argument("--role", default="member", help="Role (for add-member)")
+
+    # reindex
+    sub.add_parser("reindex", help="Rebuild search index")
+
+    # audit
+    p_audit = sub.add_parser("audit", help="View audit log and verify integrity")
+    p_audit.add_argument("--days", type=int, help="Show entries from last N days")
+    p_audit.add_argument("--verify", action="store_true", help="Verify source code checksum")
+    p_audit.add_argument("-n", type=int, default=10, help="Number of entries (default: 10)")
+
+    # delete
+    p_delete = sub.add_parser("delete", help="Delete a diary session entry")
+    p_delete.add_argument("--last", action="store_true", help="Delete the last session entry")
+    p_delete.add_argument("--session", help="Delete by session ID prefix")
+
+    # dashboard
+    p_dashboard = sub.add_parser("dashboard", help="Generate HTML dashboard")
+    p_dashboard.add_argument("--serve", action="store_true", help="Start local server")
+    p_dashboard.add_argument("--port", type=int, default=8787, help="Server port (default: 8787)")
+    p_dashboard.add_argument("--months", type=int, default=3, help="Months of data (default: 3)")
+
+    # install / uninstall
+    p_install = sub.add_parser("install", help="Register agent-diary hook in Claude Code")
+    p_install.add_argument("--force", action="store_true",
+                           help=("Refresh hook command and overwrite managed slash command files "
+                                 "(preserves user-modified ones)"))
+    install_agent = p_install.add_mutually_exclusive_group()
+    install_agent.add_argument("--codex", action="store_true",
+                               help="Also install Codex skills under ~/.codex/skills")
+    install_agent.add_argument("--codex-only", action="store_true",
+                               help="Install only Codex skills; do not modify Claude Code settings")
+    p_uninstall = sub.add_parser("uninstall", help="Remove agent-diary hook from Claude Code")
+    uninstall_agent = p_uninstall.add_mutually_exclusive_group()
+    uninstall_agent.add_argument("--codex", action="store_true",
+                                 help="Also remove Codex skills installed by claude-diary")
+    uninstall_agent.add_argument("--codex-only", action="store_true",
+                                 help="Remove only Codex skills; do not modify Claude Code settings")
+
+    # write (manual diary — for /diary slash command)
+    p_write = sub.add_parser("write", help="Write current session diary to <manual_dir>/<date>/<project>/")
+    p_write.add_argument("--input", help="JSON input file for agent-authored diary entries")
+
+    # notion (hierarchical Notion DB integration — for /diary-notion slash command)
+    _add_diary_notion_parser(sub, "diary-notion")
+    _add_diary_notion_parser(sub, "notion")
+
+    args = parser.parse_args()
+
+    if args.command is None:
+        parser.print_help()
+        return
+
+    commands = {
+        "search": cmd_search,
+        "filter": cmd_filter,
+        "trace": cmd_trace,
+        "stats": cmd_stats,
+        "weekly": cmd_weekly,
+        "config": cmd_config,
+        "init": cmd_init,
+        "migrate": cmd_migrate,
+        "reindex": cmd_reindex,
+        "team": cmd_team,
+        "audit": cmd_audit,
+        "delete": cmd_delete,
+        "dashboard": cmd_dashboard,
+        "install": cmd_install,
+        "uninstall": cmd_uninstall,
+        "write": cmd_write,
+        "diary-notion": cmd_notion,
+        "notion": cmd_notion,
+    }
+
+    fn = commands.get(args.command)
+    if fn:
+        fn(args)
+
+
+if __name__ == "__main__":
+    main()

claude_diary/cli/config.py

@@ -0,0 +1,190 @@
+"""Config, init, and migrate commands."""
+
+import json
+import os
+from pathlib import Path
+
+import claude_diary.cli as _cli
+from claude_diary.cli.setup import HOOK_COMMAND
+
+
+def cmd_config(args):
+    config = _cli.load_config()
+
+    if args.add_exporter:
+        _add_exporter_interactive(config, args.add_exporter)
+        return
+
+    if args.set_value:
+        key, _, value = args.set_value.partition("=")
+        key = key.strip()
+        value = value.strip()
+        if key == "lang":
+            if value not in ("ko", "en"):
+                print("Invalid lang: %s (use 'ko' or 'en')" % value)
+                return
+            config[key] = value
+        elif key == "diary_dir":
+            config[key] = value
+        elif key == "manual_diary_dir":
+            config[key] = value
+        elif key == "timezone_offset":
+            try:
+                tz = int(value)
+                if not (-12 <= tz <= 14):
+                    print("Invalid timezone_offset: %s (range: -12 to 14)" % value)
+                    return
+                config[key] = tz
+            except ValueError:
+                print("Invalid timezone_offset: %s (must be integer)" % value)
+                return
+        else:
+            print("Unknown config key: %s (available: lang, diary_dir, manual_diary_dir, timezone_offset)" % key)
+            return
+        _cli.save_config(config)
+        print("Set %s = %s" % (key, value))
+        return
+
+    # Display current config
+    print("Config path: %s" % _cli.get_config_path())
+    print()
+    for key, value in sorted(config.items()):
+        if key == "exporters":
+            print("exporters:")
+            for name, exp in value.items():
+                enabled = exp.get("enabled", False)
+                status = "enabled" if enabled else "disabled"
+                details = []
+                for k, v in exp.items():
+                    if k == "enabled":
+                        continue
+                    if k in ("api_token", "token", "webhook_url") and isinstance(v, str) and len(v) > 8:
+                        v = v[:4] + "..." + v[-4:]
+                    details.append("%s=%s" % (k, v))
+                detail_str = " (%s)" % ", ".join(details) if details else ""
+                print("  %s: %s%s" % (name, status, detail_str))
+        elif isinstance(value, dict):
+            print("%s: %s" % (key, json.dumps(value, ensure_ascii=False)))
+        else:
+            print("%s: %s" % (key, value))
+
+
+def _add_exporter_interactive(config, name):
+    if "exporters" not in config:
+        config["exporters"] = {}
+
+    if name == "notion":
+        token = input("Notion API token: ").strip()
+        db_id = input("Notion Database ID: ").strip()
+        config["exporters"]["notion"] = {
+            "enabled": True,
+            "api_token": token,
+            "database_id": db_id,
+        }
+    elif name in ("slack", "discord"):
+        url = input("%s Webhook URL: " % name.capitalize()).strip()
+        config["exporters"][name] = {"enabled": True, "webhook_url": url}
+    elif name == "obsidian":
+        path = input("Obsidian vault path: ").strip()
+        config["exporters"]["obsidian"] = {"enabled": True, "vault_path": path}
+    elif name == "github":
+        repo = input("GitHub repo (owner/repo): ").strip()
+        mode = input("Mode (repo/wiki/issue) [repo]: ").strip() or "repo"
+        config["exporters"]["github"] = {"enabled": True, "repo": repo, "mode": mode}
+    else:
+        print("Unknown exporter: %s" % name)
+        return
+
+    _cli.save_config(config)
+    print("Exporter '%s' added and enabled." % name)
+
+
+def cmd_init(args):
+    config = _cli.load_config()
+    diary_dir = os.path.expanduser(config["diary_dir"])
+
+    # Team mode init
+    if hasattr(args, 'team_repo') and args.team_repo:
+        from claude_diary.team import init_team
+        print("Initializing claude-diary (team mode)...")
+        print()
+        init_team(args.team_repo)
+        return
+
+    print("Initializing claude-diary...")
+    print()
+
+    # Create diary directory
+    _cli.ensure_diary_dir(diary_dir)
+    print("  [ok] Diary directory: %s" % diary_dir)
+
+    # Save config
+    _cli.save_config(config)
+    print("  [ok] Config: %s" % _cli.get_config_path())
+
+    if getattr(args, "codex_only", False) is True:
+        print("  [ok] Codex-only init: Claude Code Stop Hook not registered")
+        print()
+        print("Done! Run `agent-diary install --force --codex-only` to install Codex skills.")
+        return
+
+    # Register Stop Hook
+    claude_settings = os.path.join(os.path.expanduser("~"), ".claude", "settings.json")
+    if os.path.exists(claude_settings):
+        try:
+            with open(claude_settings, "r", encoding="utf-8") as f:
+                settings = json.load(f)
+        except (json.JSONDecodeError, IOError, ValueError):
+            settings = {}
+
+        if "hooks" not in settings:
+            settings["hooks"] = {}
+        if "Stop" not in settings["hooks"]:
+            settings["hooks"]["Stop"] = []
+
+        # Check if already registered
+        already = False
+        for group in settings["hooks"]["Stop"]:
+            for h in group.get("hooks", []):
+                if "hook.py" in h.get("command", "") or "claude_diary" in h.get("command", ""):
+                    already = True
+                    break
+
+        if not already:
+            hook_cmd = HOOK_COMMAND
+            settings["hooks"]["Stop"].append({
+                "hooks": [{"type": "command", "command": hook_cmd}]
+            })
+            with open(claude_settings, "w", encoding="utf-8") as f:
+                json.dump(settings, f, indent=2, ensure_ascii=False)
+            print("  [ok] Stop Hook registered: %s" % hook_cmd)
+        else:
+            print("  [ok] Stop Hook already registered")
+    else:
+        # Create settings.json with hook registration
+        claude_dir = os.path.join(os.path.expanduser("~"), ".claude")
+        Path(claude_dir).mkdir(parents=True, exist_ok=True)
+        hook_cmd = HOOK_COMMAND
+        settings = {
+            "hooks": {
+                "Stop": [{"hooks": [{"type": "command", "command": hook_cmd}]}]
+            }
+        }
+        with open(claude_settings, "w", encoding="utf-8") as f:
+            json.dump(settings, f, indent=2, ensure_ascii=False)
+        print("  [ok] Created %s with Stop Hook" % claude_settings)
+
+    print()
+    print("Done! Claude Code sessions will be auto-logged.")
+    print("  View diary: cat %s/$(date +%%Y-%%m-%%d).md" % diary_dir)
+
+
+def cmd_migrate(args):
+    print("Migrating v1.0 environment variables to config.json...")
+    config = _cli.migrate_from_env()
+    print("  lang: %s" % config["lang"])
+    print("  diary_dir: %s" % config["diary_dir"])
+    print("  timezone_offset: %s" % config["timezone_offset"])
+    print()
+    print("Config saved: %s" % _cli.get_config_path())
+    print("Note: Environment variables still work as fallback.")

claude_diary/cli/maintenance.py

@@ -0,0 +1,146 @@
+"""Reindex, audit, delete, and dashboard commands."""
+
+import os
+from datetime import datetime, timezone, timedelta
+from pathlib import Path
+
+import claude_diary.cli as _cli
+
+
+def cmd_reindex(args):
+    from claude_diary.indexer import reindex_all
+    config = _cli.load_config()
+    diary_dir = os.path.expanduser(config["diary_dir"])
+
+    print("Rebuilding search index...")
+    count = reindex_all(diary_dir)
+    index_path = os.path.join(diary_dir, ".diary_index.json")
+    print("Indexed %d sessions." % count)
+    print("Index: %s" % index_path)
+
+
+def cmd_audit(args):
+    from claude_diary.lib.audit import read_audit_log, verify_checksum
+    config = _cli.load_config()
+    diary_dir = os.path.expanduser(config["diary_dir"])
+
+    if args.verify:
+        is_valid, current, last = verify_checksum(diary_dir)
+        if is_valid:
+            print("Checksum OK: %s" % current)
+        else:
+            print("WARNING: Checksum mismatch!")
+            print("  Current:  %s" % current)
+            print("  Last log: %s" % last)
+            print("  Source files may have been modified since last Hook execution.")
+        return
+
+    entries = read_audit_log(diary_dir, days=args.days, limit=args.n)
+
+    if not entries:
+        print("No audit log entries found.")
+        return
+
+    print("Audit log (%d entries):" % len(entries))
+    print()
+    for e in entries:
+        ts = e.get("timestamp", "")[:19]
+        sid = e.get("session_id", "")[:8]
+        masked = e.get("secrets_masked", 0)
+        written = len(e.get("files_written", []))
+        exporters = e.get("exporters_called", [])
+        failed = e.get("exporters_failed", [])
+
+        line = "  %s | session:%s | wrote:%d" % (ts, sid, written)
+        if masked > 0:
+            line += " | secrets_masked:%d" % masked
+        if exporters:
+            line += " | exporters:%s" % ",".join(exporters)
+        if failed:
+            line += " | FAILED:%s" % ",".join(failed)
+        print(line)
+
+
+def cmd_delete(args):
+    config = _cli.load_config()
+    diary_dir = os.path.expanduser(config["diary_dir"])
+    tz_offset = config.get("timezone_offset", 9)
+    local_tz = timezone(timedelta(hours=tz_offset))
+
+    if args.last:
+        today = datetime.now(local_tz).strftime("%Y-%m-%d")
+        filepath = os.path.join(diary_dir, "%s.md" % today)
+        if not os.path.exists(filepath):
+            print("No diary file for today (%s)" % today)
+            return
+
+        # Confirmation prompt
+        confirm = input("Delete last session entry from %s? [y/N]: " % today).strip().lower()
+        if confirm not in ("y", "yes"):
+            print("Cancelled.")
+            return
+
+        with open(filepath, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        # Split by session markers and remove last
+        parts = content.split("### ⏰")
+        if len(parts) <= 1:
+            print("No session entries found in today's diary.")
+            return
+
+        # Remove last entry (everything after last "### ⏰")
+        new_content = "### ⏰".join(parts[:-1])
+        # Remove trailing "---\n\n" if present
+        new_content = new_content.rstrip()
+        if new_content.endswith("---"):
+            new_content = new_content[:-3].rstrip()
+        new_content += "\n\n"
+
+        with open(filepath, "w", encoding="utf-8") as f:
+            f.write(new_content)
+
+        print("Last session entry deleted from %s" % filepath)
+        return
+
+    if args.session:
+        # Search all files for session ID and remove that entry
+        found = False
+        for f in sorted(Path(diary_dir).glob("*.md")):
+            try:
+                content = f.read_text(encoding="utf-8")
+            except Exception:
+                continue
+            if args.session in content:
+                parts = content.split("### ⏰")
+                new_parts = [parts[0]]
+                for part in parts[1:]:
+                    if args.session not in part:
+                        new_parts.append(part)
+                    else:
+                        found = True
+                new_content = "### ⏰".join(new_parts).rstrip() + "\n"
+                f.write_text(new_content, encoding="utf-8")
+                print("Session %s deleted from %s" % (args.session, f.name))
+                break
+
+        if not found:
+            print("Session '%s' not found." % args.session)
+        return
+
+    print("Specify --last or --session <id>")
+
+
+def cmd_dashboard(args):
+    from claude_diary.dashboard import generate_dashboard, serve_dashboard
+    config = _cli.load_config()
+    diary_dir = os.path.expanduser(config["diary_dir"])
+
+    path = generate_dashboard(diary_dir, months=args.months)
+    print("Dashboard generated: %s" % path)
+
+    if args.serve:
+        serve_dashboard(diary_dir, port=args.port)
+    else:
+        import webbrowser
+        webbrowser.open("file://%s" % os.path.abspath(path))

claude_diary/cli/notion_common.py

@@ -0,0 +1,30 @@
+"""Helpers shared by the `diary-notion` subcommands that read Notion rows."""
+
+from datetime import datetime, timezone, timedelta
+
+
+def resolve_year_and_today(config, explicit_year):
+    """Return (year, "YYYY-MM-DD") in the configured local timezone."""
+    tz_offset = config.get("timezone_offset", 9)
+    local_tz = timezone(timedelta(hours=tz_offset))
+    now = datetime.now(local_tz)
+    year = explicit_year or now.year
+    return year, now.strftime("%Y-%m-%d")
+
+
+def plain_text(item):
+    return item.get("plain_text") or ((item.get("text") or {}).get("content")) or ""
+
+
+def title_value(prop):
+    values = (prop or {}).get("title") or []
+    text = "".join(plain_text(item) for item in values).strip()
+    return text or "(untitled)"
+
+
+def select_value(prop):
+    return ((prop or {}).get("select") or {}).get("name") or ""
+
+
+def date_start_value(prop):
+    return ((prop or {}).get("date") or {}).get("start") or ""