devmemory 0.1.0__py3-none-any.whl

devmemory/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.1.0"
+__app_name__ = "devmemory"

devmemory/cli.py

@@ -0,0 +1,99 @@
+import typer
+from devmemory.commands.config_cmd import app as config_app
+
+app = typer.Typer(
+    name="devmemory",
+    help="Sync AI coding context from Git AI to Redis Agent Memory Server for semantic search and recall.",
+    no_args_is_help=True,
+)
+
+app.add_typer(config_app, name="config", help="Manage devmemory configuration.")
+
+
+@app.command()
+def sync(
+    latest: bool = typer.Option(False, "--latest", help="Sync only the latest commit."),
+    all_commits: bool = typer.Option(False, "--all", help="Sync all commits (ignore last synced state)."),
+    ai_only: bool = typer.Option(True, "--ai-only/--include-human", help="Only sync commits with AI notes."),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Show what would be synced without sending."),
+    limit: int = typer.Option(50, "--limit", help="Max commits to process."),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Minimal output (single summary line)."),
+):
+    """Sync Git AI notes to Redis AMS."""
+    from devmemory.commands.sync import run_sync
+    run_sync(latest=latest, all_commits=all_commits, ai_only=ai_only, dry_run=dry_run, limit=limit, quiet=quiet)
+
+
+@app.command()
+def search(
+    query: str = typer.Argument(..., help="Search query (natural language)."),
+    limit: int = typer.Option(10, "--limit", "-n", help="Max results to return."),
+    namespace: str = typer.Option("", "--namespace", "-ns", help="Filter by namespace."),
+    topic: list[str] = typer.Option([], "--topic", "-t", help="Filter by topic(s)."),
+    memory_type: str = typer.Option("", "--type", help="Filter by memory type (episodic, semantic)."),
+    threshold: float = typer.Option(0.75, "--threshold", help="Relevance threshold (0-1, lower=stricter). Results with distance above this are filtered."),
+    raw: bool = typer.Option(False, "--raw", help="Raw output mode: skip answer synthesis and show memory panels directly."),
+):
+    """Search the project knowledgebase with AI-powered answer synthesis."""
+    from devmemory.commands.search import run_search
+    run_search(query=query, limit=limit, namespace=namespace, topic=topic, memory_type=memory_type, threshold=threshold, raw=raw)
+
+
+@app.command()
+def status():
+    """Show system status."""
+    from devmemory.commands.status import run_status
+    run_status()
+
+
+@app.command()
+def add(
+    text: str = typer.Argument("", help="Memory text to store. If empty, launches interactive mode."),
+    memory_type: str = typer.Option("semantic", "--type", help="Memory type: semantic (facts/decisions) or episodic (events)."),
+    topic: list[str] = typer.Option([], "--topic", "-t", help="Topic tags (can specify multiple)."),
+    entity: list[str] = typer.Option([], "--entity", "-e", help="Entity tags (can specify multiple)."),
+    interactive: bool = typer.Option(False, "--interactive", "-i", help="Interactive mode with prompts."),
+):
+    """Add a memory directly (design decisions, gotchas, conventions, etc.)."""
+    from devmemory.commands.add import run_add
+    run_add(text=text, memory_type=memory_type, topics=topic or None, entities=entity or None, interactive=interactive)
+
+
+@app.command()
+def learn(
+    path: str = typer.Argument("", help="Path to knowledge directory (default: .devmemory/knowledge/)."),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Show what would be synced without sending."),
+):
+    """Sync knowledge files (markdown) into the memory store."""
+    from devmemory.commands.learn import run_learn
+    run_learn(path=path, dry_run=dry_run)
+
+
+@app.command()
+def context(
+    output: str = typer.Option("", "--output", "-o", help="Output file path (default: .devmemory/CONTEXT.md)."),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="No terminal output, just write the file."),
+):
+    """Generate a context briefing from memory based on current git state."""
+    from devmemory.commands.context import run_context
+    run_context(output=output, quiet=quiet)
+
+
+@app.command()
+def install(
+    skip_hook: bool = typer.Option(False, "--skip-hook", help="Skip post-commit hook installation."),
+    skip_mcp: bool = typer.Option(False, "--skip-mcp", help="Skip Cursor MCP config."),
+    skip_rule: bool = typer.Option(False, "--skip-rule", help="Skip Cursor agent rule installation."),
+    mcp_endpoint: str = typer.Option("", "--mcp-endpoint", help="Override MCP server endpoint."),
+):
+    """Set up Git hooks, Cursor MCP config, and agent coordination rules."""
+    from devmemory.commands.install import run_install
+    run_install(skip_hook=skip_hook, skip_mcp=skip_mcp, skip_rule=skip_rule, mcp_endpoint=mcp_endpoint)
+
+
+def main():
+    app()
+
+
+if __name__ == "__main__":
+    main()

devmemory/commands/__init__.py

@@ -0,0 +1 @@
+

devmemory/commands/add.py

@@ -0,0 +1,160 @@
+import hashlib
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from devmemory.core.config import DevMemoryConfig
+from devmemory.core.ams_client import AMSClient
+
+console = Console()
+
+VALID_TYPES = ("semantic", "episodic")
+
+
+def _generate_id(text: str) -> str:
+    return hashlib.sha256(f"manual:{text}".encode()).hexdigest()[:24]
+
+
+def run_add(
+    text: str = "",
+    memory_type: str = "semantic",
+    topics: list[str] | None = None,
+    entities: list[str] | None = None,
+    interactive: bool = False,
+):
+    config = DevMemoryConfig.load()
+    client = AMSClient(base_url=config.ams_endpoint)
+
+    try:
+        client.health_check()
+    except Exception as e:
+        console.print(f"[red]Cannot reach AMS at {config.ams_endpoint}: {e}[/red]")
+        raise typer.Exit(1)
+
+    if interactive or not text:
+        text = _interactive_prompt(memory_type, topics, entities)
+        if text is None:
+            raise typer.Exit(0)
+        return
+
+    if memory_type not in VALID_TYPES:
+        console.print(f"[red]Invalid memory type '{memory_type}'. Must be one of: {', '.join(VALID_TYPES)}[/red]")
+        raise typer.Exit(1)
+
+    memory = {
+        "id": _generate_id(text),
+        "text": text,
+        "memory_type": memory_type,
+        "namespace": config.namespace or "default",
+    }
+    if topics:
+        memory["topics"] = topics
+    if entities:
+        memory["entities"] = entities
+    if config.user_id:
+        memory["user_id"] = config.user_id
+
+    try:
+        client.create_memories([memory])
+    except Exception as e:
+        console.print(f"[red]Failed to store memory: {e}[/red]")
+        raise typer.Exit(1)
+
+    console.print(Panel(
+        text,
+        title=f"[bold green]Stored[/bold green] [{memory_type}]",
+        border_style="green",
+        padding=(0, 1),
+    ))
+    if topics:
+        console.print(f"  [dim]Topics: {', '.join(topics)}[/dim]")
+    if entities:
+        console.print(f"  [dim]Entities: {', '.join(entities)}[/dim]")
+
+
+def _interactive_prompt(
+    default_type: str = "semantic",
+    default_topics: list[str] | None = None,
+    default_entities: list[str] | None = None,
+) -> str | None:
+    config = DevMemoryConfig.load()
+    client = AMSClient(base_url=config.ams_endpoint)
+
+    console.print("[bold]Add a memory[/bold]\n")
+    console.print("[dim]Types of knowledge to store:[/dim]")
+    console.print("  - Architecture decisions and rationale")
+    console.print("  - Known gotchas and workarounds")
+    console.print("  - Project conventions and patterns")
+    console.print("  - Bug root causes")
+    console.print("  - API quirks and limitations")
+    console.print()
+
+    text = typer.prompt("Memory text (what do you want to remember?)")
+    if not text.strip():
+        console.print("[yellow]No text provided, aborting.[/yellow]")
+        return None
+
+    type_input = typer.prompt(
+        "Memory type",
+        default=default_type,
+        show_default=True,
+    )
+    if type_input not in VALID_TYPES:
+        console.print(f"[yellow]Invalid type, using 'semantic'[/yellow]")
+        type_input = "semantic"
+
+    topics_default = ", ".join(default_topics) if default_topics else ""
+    topics_input = typer.prompt(
+        "Topics (comma-separated, e.g. architecture,patterns)",
+        default=topics_default,
+        show_default=bool(topics_default),
+    )
+    topics = [t.strip() for t in topics_input.split(",") if t.strip()] if topics_input else []
+
+    entities_default = ", ".join(default_entities) if default_entities else ""
+    entities_input = typer.prompt(
+        "Entities (comma-separated, e.g. Redis,httpx)",
+        default=entities_default,
+        show_default=bool(entities_default),
+    )
+    entities = [e.strip() for e in entities_input.split(",") if e.strip()] if entities_input else []
+
+    memory = {
+        "id": _generate_id(text),
+        "text": text,
+        "memory_type": type_input,
+        "namespace": config.namespace or "default",
+    }
+    if topics:
+        memory["topics"] = topics
+    if entities:
+        memory["entities"] = entities
+    if config.user_id:
+        memory["user_id"] = config.user_id
+
+    console.print()
+    console.print(Panel(
+        text,
+        title=f"[bold]Preview[/bold] [{type_input}]",
+        border_style="dim",
+        padding=(0, 1),
+    ))
+    if topics:
+        console.print(f"  [dim]Topics: {', '.join(topics)}[/dim]")
+    if entities:
+        console.print(f"  [dim]Entities: {', '.join(entities)}[/dim]")
+    console.print()
+
+    if not typer.confirm("Store this memory?", default=True):
+        console.print("[yellow]Cancelled.[/yellow]")
+        return None
+
+    try:
+        client.create_memories([memory])
+    except Exception as e:
+        console.print(f"[red]Failed to store memory: {e}[/red]")
+        raise typer.Exit(1)
+
+    console.print("[bold green]Memory stored.[/bold green]")
+    return text

devmemory/commands/config_cmd.py

@@ -0,0 +1,44 @@
+import typer
+from rich.console import Console
+from rich.table import Table
+from dataclasses import asdict
+
+from devmemory.core.config import DevMemoryConfig
+
+app = typer.Typer()
+console = Console()
+
+
+@app.command("show")
+def show():
+    config = DevMemoryConfig.load()
+    table = Table(title="DevMemory Configuration", show_header=True, border_style="dim")
+    table.add_column("Key", style="bold")
+    table.add_column("Value")
+
+    for key, value in asdict(config).items():
+        display = value if value else "[dim]not set[/dim]"
+        table.add_row(key, str(display))
+
+    console.print(table)
+
+
+@app.command("set")
+def set_value(
+    key: str = typer.Argument(..., help="Config key to set."),
+    value: str = typer.Argument(..., help="Value to set."),
+):
+    config = DevMemoryConfig.load()
+    try:
+        config.set_value(key, value)
+        console.print(f"[green]Set {key} = {value}[/green]")
+    except KeyError as e:
+        console.print(f"[red]{e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command("reset")
+def reset():
+    config = DevMemoryConfig()
+    config.save()
+    console.print("[green]Config reset to defaults.[/green]")

devmemory/commands/context.py

@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+import subprocess
+from datetime import datetime, timezone
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from devmemory.core.config import DevMemoryConfig
+from devmemory.core.ams_client import AMSClient, MemoryResult
+
+console = Console()
+
+DEFAULT_OUTPUT = ".devmemory/CONTEXT.md"
+RELEVANCE_THRESHOLD = 0.65
+MAX_CONTEXT_CHARS = 4000
+MAX_RESULTS_PER_QUERY = 5
+
+
+def _git_cmd(args: list[str]) -> str:
+    try:
+        result = subprocess.run(
+            ["git"] + args,
+            capture_output=True, text=True, check=True,
+        )
+        return result.stdout.strip()
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return ""
+
+
+def _get_git_signals() -> dict:
+    branch = _git_cmd(["rev-parse", "--abbrev-ref", "HEAD"])
+
+    changed_raw = _git_cmd(["diff", "--name-only"])
+    staged_raw = _git_cmd(["diff", "--cached", "--name-only"])
+    all_changed = set()
+    if changed_raw:
+        all_changed.update(changed_raw.splitlines())
+    if staged_raw:
+        all_changed.update(staged_raw.splitlines())
+
+    recent_log = _git_cmd(["log", "--oneline", "-5", "--format=%s"])
+    recent_subjects = [s.strip() for s in recent_log.splitlines() if s.strip()] if recent_log else []
+
+    recent_files_raw = _git_cmd(["log", "--name-only", "--format=", "-3"])
+    recent_files = set()
+    if recent_files_raw:
+        for f in recent_files_raw.splitlines():
+            f = f.strip()
+            if f:
+                recent_files.add(f)
+
+    return {
+        "branch": branch or "unknown",
+        "changed_files": sorted(all_changed),
+        "recent_subjects": recent_subjects,
+        "recent_files": sorted(recent_files),
+    }
+
+
+def _build_search_queries(signals: dict) -> list[str]:
+    queries = []
+
+    branch = signals["branch"]
+    if branch and branch not in ("main", "master", "HEAD", "unknown"):
+        clean_branch = branch.replace("/", " ").replace("-", " ").replace("_", " ")
+        queries.append(clean_branch)
+
+    changed = signals["changed_files"]
+    if changed:
+        dirs = set()
+        for f in changed[:10]:
+            parts = f.rsplit("/", 1)
+            if len(parts) == 2:
+                dirs.add(parts[0].split("/")[-1])
+        if dirs:
+            queries.append(f"known issues and patterns in {' '.join(sorted(dirs)[:5])}")
+        file_list = " ".join(changed[:5])
+        queries.append(f"architecture decisions for {file_list}")
+
+    subjects = signals["recent_subjects"]
+    if subjects:
+        combined = "; ".join(subjects[:3])
+        queries.append(f"context for recent work: {combined}")
+
+    if not queries:
+        queries.append("project architecture and conventions")
+
+    return queries[:5]
+
+
+def _search_with_dedup(
+    client: AMSClient,
+    queries: list[str],
+    namespace: str | None,
+    threshold: float = RELEVANCE_THRESHOLD,
+) -> list[MemoryResult]:
+    seen_ids: set[str] = set()
+    results: list[MemoryResult] = []
+
+    for query in queries:
+        try:
+            hits = client.search_memories(
+                text=query,
+                limit=MAX_RESULTS_PER_QUERY,
+                namespace=namespace,
+                memory_type="semantic",
+            )
+        except Exception:
+            continue
+
+        for r in hits:
+            if r.score < threshold and r.id not in seen_ids:
+                seen_ids.add(r.id)
+                results.append(r)
+
+    results.sort(key=lambda r: r.score)
+    return results
+
+
+def _fetch_coordination_state(client: AMSClient) -> str | None:
+    try:
+        sessions = client.list_sessions(limit=10)
+        for sid in sessions:
+            if "coordination" in sid.lower():
+                return sid
+    except Exception:
+        pass
+    return None
+
+
+def _truncate_memory_text(text: str, max_len: int = 200) -> str:
+    lines = text.strip().splitlines()
+    first_line = lines[0] if lines else ""
+    if len(first_line) > max_len:
+        return first_line[:max_len] + "..."
+    if len(lines) == 1:
+        return first_line
+
+    result = first_line
+    for line in lines[1:]:
+        if len(result) + len(line) + 1 > max_len:
+            break
+        result += "\n" + line
+    return result
+
+
+def _render_context(
+    signals: dict,
+    results: list[MemoryResult],
+    coordination_session: str | None,
+) -> str:
+    now = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")
+    parts = [
+        f"# DevMemory Context",
+        f"_Auto-generated at {now}. Run `devmemory context` to refresh._\n",
+    ]
+
+    parts.append(f"## Current Branch: `{signals['branch']}`\n")
+
+    if signals["changed_files"]:
+        parts.append("## Active Changes\n")
+        for f in signals["changed_files"][:15]:
+            parts.append(f"- `{f}`")
+        if len(signals["changed_files"]) > 15:
+            parts.append(f"- ... and {len(signals['changed_files']) - 15} more")
+        parts.append("")
+
+    if signals["recent_subjects"]:
+        parts.append("## Recent Commits\n")
+        for s in signals["recent_subjects"]:
+            parts.append(f"- {s}")
+        parts.append("")
+
+    decisions = [r for r in results if any(
+        t in r.topics for t in ("architecture", "decisions", "conventions", "dependencies")
+    )]
+    gotchas = [r for r in results if any(
+        t in r.topics for t in ("gotchas", "troubleshooting", "bugfix", "api-quirks")
+    )]
+    other = [r for r in results if r not in decisions and r not in gotchas]
+
+    total_chars = sum(len(p) for p in parts)
+
+    if decisions:
+        parts.append("## Relevant Architecture Decisions\n")
+        for r in decisions:
+            summary = _truncate_memory_text(r.text)
+            parts.append(f"- **{summary.splitlines()[0]}**")
+            remaining = "\n".join(summary.splitlines()[1:]).strip()
+            if remaining:
+                for line in remaining.splitlines():
+                    parts.append(f"  {line}")
+            total_chars += len(summary)
+            if total_chars > MAX_CONTEXT_CHARS:
+                break
+        parts.append("")
+
+    if gotchas and total_chars < MAX_CONTEXT_CHARS:
+        parts.append("## Known Gotchas for This Area\n")
+        for r in gotchas:
+            summary = _truncate_memory_text(r.text)
+            parts.append(f"- **{summary.splitlines()[0]}**")
+            remaining = "\n".join(summary.splitlines()[1:]).strip()
+            if remaining:
+                for line in remaining.splitlines():
+                    parts.append(f"  {line}")
+            total_chars += len(summary)
+            if total_chars > MAX_CONTEXT_CHARS:
+                break
+        parts.append("")
+
+    if other and total_chars < MAX_CONTEXT_CHARS:
+        parts.append("## Other Relevant Context\n")
+        for r in other:
+            summary = _truncate_memory_text(r.text, max_len=150)
+            first = summary.splitlines()[0]
+            parts.append(f"- [{r.memory_type}] {first}")
+            total_chars += len(first)
+            if total_chars > MAX_CONTEXT_CHARS:
+                break
+        parts.append("")
+
+    if coordination_session:
+        parts.append("## Active Coordination\n")
+        parts.append(f"- Active coordination session found: `{coordination_session}`")
+        parts.append("- Use `get_working_memory(session_id=\"project-coordination\")` via MCP to read details")
+        parts.append("")
+
+    if not results:
+        parts.append("## No Relevant Memories Found\n")
+        parts.append("No memories matched the current work area above the relevance threshold.")
+        parts.append("Use `devmemory search \"<query>\"` for broader searches.")
+        parts.append("")
+
+    parts.append("---")
+    parts.append(f"_Searched {len(results)} relevant memories across {len(signals.get('changed_files', []))} changed files._")
+    parts.append("_For deeper context, use `devmemory search \"<specific question>\"` or `search_long_term_memory()` via MCP._")
+
+    return "\n".join(parts) + "\n"
+
+
+def run_context(
+    output: str = "",
+    quiet: bool = False,
+):
+    config = DevMemoryConfig.load()
+    client = AMSClient(base_url=config.ams_endpoint)
+
+    try:
+        client.health_check()
+    except Exception:
+        if not quiet:
+            console.print("[yellow]AMS not reachable — generating context from git signals only.[/yellow]")
+        signals = _get_git_signals()
+        content = _render_context(signals, [], None)
+        _write_output(content, output, quiet)
+        return
+
+    if not quiet:
+        console.print("[dim]Collecting git signals...[/dim]")
+
+    signals = _get_git_signals()
+    queries = _build_search_queries(signals)
+
+    if not quiet:
+        console.print(f"[dim]Searching memory with {len(queries)} queries...[/dim]")
+
+    ns = config.namespace or None
+    results = _search_with_dedup(client, queries, ns)
+    coordination = _fetch_coordination_state(client)
+    content = _render_context(signals, results, coordination)
+    _write_output(content, output, quiet)
+
+    if not quiet:
+        console.print(f"[green]Context generated with {len(results)} relevant memories.[/green]")
+
+
+def _write_output(content: str, output: str, quiet: bool):
+    out_path = Path(output) if output else Path.cwd() / DEFAULT_OUTPUT
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_text(content)
+    if not quiet:
+        console.print(f"[dim]Written to {out_path}[/dim]")