klyd 0.1.0__tar.gz

klyd-0.1.0/AGENTS.md.txt

@@ -0,0 +1,25 @@
+# AGENTS.md
+
+## What this project is
+klyd: a CLI tool that wraps coding agents via git hooks to inject architectural memory.
+
+## Stack (frozen — do not deviate)
+- Python 3.11+
+- Click for CLI
+- SQLite via stdlib sqlite3 (no ORM)
+- POSIX shell for hook scripts
+- Anthropic API (claude-sonnet-4-6) via BYOK
+
+## Module responsibilities (do not blur these)
+- cli.py: Click entrypoint only. No business logic.
+- db.py: All SQLite operations. Nothing else.
+- extractor.py: One function — LLM extraction call. Nothing else.
+- injector.py: One function — format injection string. Nothing else.
+- hooks.py: Install/uninstall git hooks. Nothing else.
+
+## Hard rules
+- Two LLM calls per commit cycle maximum
+- No external dependencies beyond Click and anthropic SDK
+- Every function does one thing
+- Shell hooks are dumb — they call klyd CLI, contain no logic themselves
+- Never add a dependency to solve a problem that stdlib solves

klyd-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 klyd contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

klyd-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include hooks/*.sh
+include AGENTS.md.txt

klyd-0.1.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: klyd
+Version: 0.1.0
+Summary: A CLI tool that wraps coding agents via git hooks to inject architectural memory.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click
+Requires-Dist: anthropic
+Dynamic: license-file
+
+<center>
+
+```ascii
+
+           ▄█   ▄█▄            ▄█                 ▄██   ▄             ████████▄            
+          ███ ▄███▀           ███                 ███   ██▄           ███   ▀███           
+          ███▐██▀             ███                 ███▄▄▄███           ███    ███           
+         ▄█████▀              ███                 ▀▀▀▀▀▀███           ███    ███           
+        ▀▀█████▄              ███                 ▄██   ███           ███    ███           
+          ███▐██▄             ███                 ███   ███           ███    ███           
+          ███ ▀███▄           ███▌    ▄           ███   ███           ███   ▄███           
+          ███   ▀█▀           █████▄▄██            ▀█████▀            ████████▀            
+          ▀                   ▀                                                            
+
+```
+</center>
+
+install → klyd init → klyd config --api-key sk-... → klyd run aider
+
+## Quickstart
+
+```bash
+# 1. Install
+pip install .
+
+# 2. Initialize in your repo
+cd your-project
+klyd init
+
+# 3. Configure an API Key
+# Anthropic (Default)
+klyd config --api-key sk-ant-...
+
+# OR OpenAI
+klyd config --openai-key sk-proj-... --model gpt-4o
+
+# OR OpenRouter
+klyd config --openrouter-key sk-or-... --model openrouter/auto
+
+# OR Gemini
+klyd config --gemini-key AIza... --model gemini-1.5-pro
+
+# OR Groq
+klyd config --groq-key gsk_... --model llama3-8b-8192
+
+# 4. Use your agent as normal
+klyd run aider
+```
+
+Decisions will automatically populate after you make commits. Review flagged contradictions using `klyd review`. Check current status with `klyd status`.

klyd-0.1.0/README.md

@@ -0,0 +1,50 @@
+<center>
+
+```ascii
+
+           ▄█   ▄█▄            ▄█                 ▄██   ▄             ████████▄            
+          ███ ▄███▀           ███                 ███   ██▄           ███   ▀███           
+          ███▐██▀             ███                 ███▄▄▄███           ███    ███           
+         ▄█████▀              ███                 ▀▀▀▀▀▀███           ███    ███           
+        ▀▀█████▄              ███                 ▄██   ███           ███    ███           
+          ███▐██▄             ███                 ███   ███           ███    ███           
+          ███ ▀███▄           ███▌    ▄           ███   ███           ███   ▄███           
+          ███   ▀█▀           █████▄▄██            ▀█████▀            ████████▀            
+          ▀                   ▀                                                            
+
+```
+</center>
+
+install → klyd init → klyd config --api-key sk-... → klyd run aider
+
+## Quickstart
+
+```bash
+# 1. Install
+pip install .
+
+# 2. Initialize in your repo
+cd your-project
+klyd init
+
+# 3. Configure an API Key
+# Anthropic (Default)
+klyd config --api-key sk-ant-...
+
+# OR OpenAI
+klyd config --openai-key sk-proj-... --model gpt-4o
+
+# OR OpenRouter
+klyd config --openrouter-key sk-or-... --model openrouter/auto
+
+# OR Gemini
+klyd config --gemini-key AIza... --model gemini-1.5-pro
+
+# OR Groq
+klyd config --groq-key gsk_... --model llama3-8b-8192
+
+# 4. Use your agent as normal
+klyd run aider
+```
+
+Decisions will automatically populate after you make commits. Review flagged contradictions using `klyd review`. Check current status with `klyd status`.

klyd-0.1.0/hooks/post-commit.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+kl extract-commit >> .klyd/errors.log 2>&1 &

klyd-0.1.0/hooks/pre-commit.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+kl prepare-injection >> .klyd/errors.log 2>&1 || true

klyd-0.1.0/klyd/__init__.py

@@ -0,0 +1,10 @@
+import sys
+
+frame = sys._getframe()
+while frame:
+    if frame.f_code.co_name == '_get_module_details' and frame.f_locals.get('mod_name') == 'klyd.__main__':
+        from klyd.cli import cli
+        sys.argv[0] = 'python -m klyd'
+        cli()
+        sys.exit(0)
+    frame = frame.f_back

klyd-0.1.0/klyd/cli.py

@@ -0,0 +1,454 @@
+import click
+import subprocess
+import json
+import traceback
+from .hooks import install_hooks
+from .config import init_config, set_config, get_config, get_all_config
+from .db import get_schema_path
+import sqlite3
+from pathlib import Path
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.rule import Rule
+from rich.columns import Columns
+from rich.prompt import Prompt
+from rich.text import Text
+import rich.box
+
+console = Console()
+
+class KlydGroup(click.Group):
+    def format_help(self, ctx, formatter):
+        console.print()
+        console.print()
+        console.print(r"[yellow bold]888  /         888           Y88b    /       888~-_   [/yellow bold]")
+        console.print(r"[yellow bold]888 /          888            Y88b  /        888   \  [/yellow bold]")
+        console.print(r"[yellow bold]888/\          888             Y88b/         888    | [/yellow bold]")
+        console.print(r"[yellow bold]888  \         888              Y8Y          888    | [/yellow bold]")
+        console.print(r"[yellow bold]888   \        888               Y           888   /  [/yellow bold]")
+        console.print(r"[yellow bold]888    \       888____          /            888_-~   [/yellow bold]")
+        console.print()
+        console.print(r"[dim]        (An open-source project, not affiliated with the Klyd SaaS)[/dim]")
+        console.print()
+        console.print()
+        super().format_help(ctx, formatter)
+
+@click.group(cls=KlydGroup)
+def cli():
+    """klyd: a CLI tool that wraps coding agents via git hooks to inject architectural memory."""
+    pass
+
+def echo_brand(msg, bold=False):
+    console.print(f"[cyan bold]klyd[/cyan bold] | {msg}")
+
+@cli.command()
+def init():
+    """Initialize klyd in the current git repository."""
+    console.print()
+    console.print()
+    console.print(r"[green bold]8 8888     ,88'           8 8888                   `8.`8888.      ,8'           8 888888888o.      [/green bold]")
+    console.print(r"[green bold]8 8888    ,88'            8 8888                    `8.`8888.    ,8'            8 8888    `^888.   [/green bold]")
+    console.print(r"[green bold]8 8888   ,88'             8 8888                     `8.`8888.  ,8'             8 8888        `88. [/green bold]")
+    console.print(r"[green bold]8 8888  ,88'              8 8888                      `8.`8888.,8'              8 8888         `88 [/green bold]")
+    console.print(r"[green bold]8 8888 ,88'               8 8888                       `8.`88888'               8 8888          88 [/green bold]")
+    console.print(r"[green bold]8 8888 88'                8 8888                        `8. 8888                8 8888          88 [/green bold]")
+    console.print(r"[green bold]8 888888<                 8 8888                         `8 8888                8 8888         ,88 [/green bold]")
+    console.print(r"[green bold]8 8888 `Y8.               8 8888                          8 8888                8 8888        ,88' [/green bold]")
+    console.print(r"[green bold]8 8888   `Y8.             8 8888                          8 8888                8 8888    ,o88P'   [/green bold]")
+    console.print(r"[green bold]8 8888     `Y8.           8 888888888888                  8 8888                8 888888888P'      [/green bold]")
+    console.print()
+    console.print(r"                   [dim](An open-source project, not affiliated with the Klyd SaaS)[/dim]")
+    console.print()
+    console.print()
+    try:
+        with console.status("[bold cyan]Creating .klyd directory, database, and hooks...[/bold cyan]", spinner="dots12"):
+            install_hooks()
+            init_config()
+            klyd_dir = Path('.klyd')
+            db_path = klyd_dir / 'memory.db'
+            from .db import init_db
+            init_db(str(db_path))
+            
+        console.print(Panel(
+            "Klyd harness initialised in [cyan].klyd[/cyan]\n\n[dim]Installed git hooks for automatic extraction.[/dim]\n[dim]Errors are logged to .klyd/errors.log[/dim]",
+            title="[bold green]SUCCESS[/bold green]", border_style="green", padding=(1, 2)
+        ))
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise click.Abort()
+
+@cli.command()
+@click.option('--api-key', help='Anthropic API key')
+@click.option('--openai-key', help='OpenAI API key')
+@click.option('--openrouter-key', help='OpenRouter API key')
+@click.option('--gemini-key', help='Gemini API key')
+@click.option('--groq-key', help='Groq API key')
+@click.option('--model', help='Model to use (default: claude-sonnet-4-6)')
+@click.option('--show', is_flag=True, help='Show current configuration')
+def config(api_key, openai_key, openrouter_key, gemini_key, groq_key, model, show):
+    """Set klyd configuration."""
+    if show:
+        cfg = get_all_config()
+        table = Table(title="[bold cyan]klyd Configuration[/bold cyan]", box=rich.box.SIMPLE, header_style="bold cyan")
+        table.add_column("Key", style="cyan")
+        table.add_column("Value", style="green")
+        if not cfg:
+            table.add_row("[dim]No configuration set[/dim]", "[dim]Run: kl config --api-key ...[/dim]")
+        else:
+            for k, v in cfg.items():
+                if 'key' in k and v:
+                    v = v[:4] + '*' * (len(v) - 8) + v[-4:] if len(v) > 8 else '*' * len(v)
+                table.add_row(k, v)
+        console.print(table)
+        return
+
+    changes = False
+    with console.status("[bold cyan]Saving configuration...[/bold cyan]", spinner="dots12"):
+        if api_key:
+            set_config('api_key', api_key)
+            changes = True
+        if openai_key:
+            set_config('openai_key', openai_key)
+            changes = True
+        if openrouter_key:
+            set_config('openrouter_key', openrouter_key)
+            changes = True
+        if gemini_key:
+            set_config('gemini_key', gemini_key)
+            changes = True
+        if groq_key:
+            set_config('groq_key', groq_key)
+            changes = True
+        if model:
+            set_config('model', model)
+            changes = True
+            
+    if changes:
+        console.print(Panel("[bold green]Configuration saved successfully[/bold green]", title="[bold green]DONE[/bold green]", border_style="green", expand=False))
+    else:
+        console.print("[yellow]Usage:[/yellow] kl config --api-key ... --openai-key ... --model ...\nOr use --show to display current configuration.")
+
+@cli.command(context_settings={"ignore_unknown_options": True})
+@click.option('--no-inject', is_flag=True, help='Skip generating injection file')
+@click.argument('cmd', nargs=-1, type=click.UNPROCESSED)
+def run(no_inject, cmd):
+    """Run an agent with injected architectural memory."""
+    if not cmd:
+        console.print("Usage: kl run <agent> [args...]")
+        return
+        
+    klyd_dir = Path('.klyd')
+    inj_path = klyd_dir / 'injection.txt'
+    
+    if not no_inject:
+        with console.status("[bold cyan]Preparing injection context...[/bold cyan]", spinner="dots12"):
+            try:
+                ctx = click.get_current_context()
+                ctx.invoke(prepare_injection)
+            except Exception as e:
+                pass
+            
+    run_cmd = list(cmd)
+    agent_name = run_cmd[0].lower()
+    
+    if inj_path.exists() and inj_path.stat().st_size > 0:
+        if agent_name == 'aider':
+            run_cmd.extend(['--message-file', str(inj_path)])
+        elif agent_name == 'opencode':
+            run_cmd.extend(['-m', inj_path.read_text()])
+            
+    console.print(Panel(f"[bold cyan]Launching[/bold cyan] {agent_name}...", title="[bold blue]AGENT START[/bold blue]", border_style="blue", expand=False))
+    
+    try:
+        subprocess.run(run_cmd)
+        console.print(Panel("[bold green]Agent session ended[/bold green]", title="[bold green]DONE[/bold green]", border_style="green", expand=False))
+    except FileNotFoundError:
+        console.print(f"[red]Command not found: {cmd[0]}[/red]")
+
+@cli.command()
+def extract_commit():
+    """Extract decisions from the last commit."""
+    from .extractor import extract_decisions
+    from .db import get_decisions_for_files, store_decision, reinforce_decision, flag_decision
+    
+    klyd_dir = Path('.klyd')
+    if not (klyd_dir / 'memory.db').exists():
+        return
+        
+    try:
+        try:
+            diff = subprocess.check_output(['git', 'diff', 'HEAD~1', 'HEAD'], text=True)
+            msg = subprocess.check_output(['git', 'log', '-1', '--format=%B'], text=True)
+            files_out = subprocess.check_output(['git', 'diff', '--name-only', 'HEAD~1', 'HEAD'], text=True)
+            files = [f for f in files_out.strip().split('\n') if f]
+            commit_hash = subprocess.check_output(['git', 'rev-parse', 'HEAD'], text=True).strip()
+        except subprocess.CalledProcessError:
+            diff = subprocess.check_output(['git', 'show', 'HEAD'], text=True)
+            msg = subprocess.check_output(['git', 'log', '-1', '--format=%B'], text=True)
+            files_out = subprocess.check_output(['git', 'show', '--name-only', '--format=', 'HEAD'], text=True)
+            files = [f for f in files_out.strip().split('\n') if f]
+            commit_hash = subprocess.check_output(['git', 'rev-parse', 'HEAD'], text=True).strip()
+
+        if not files:
+            return
+
+        with console.status("[bold cyan]Extracting architectural decisions via LLM...[/bold cyan]", spinner="dots12"):
+            db_path = str(klyd_dir / 'memory.db')
+            existing = get_decisions_for_files(db_path, files, top_k=20)
+            existing_json = json.dumps(existing, indent=2)
+
+            config_data = get_all_config()
+            model = config_data.get('model', 'claude-sonnet-4-6')
+            
+            decisions = extract_decisions(diff, msg, existing_json, config_data, model)
+
+            new_count = 0
+            reinforced_count = 0
+
+            for d in decisions:
+                event = d.get('event_type')
+                
+                if event == 'REINFORCE':
+                    match = next((e for e in existing if e['module'] == d['module'] and e['decision'] == d['decision']), None)
+                    if match:
+                        reinforce_decision(db_path, match['id'], commit_hash)
+                        reinforced_count += 1
+                    else:
+                        d['event_type'] = 'NEW'
+                        store_decision(db_path, d)
+                        new_count += 1
+                elif event == 'CONTRADICT':
+                    did = store_decision(db_path, d)
+                    flag_decision(db_path, did)
+                    new_count += 1
+                else:
+                    store_decision(db_path, d)
+                    new_count += 1
+                    
+        if new_count > 0 or reinforced_count > 0:
+            console.print(Panel(
+                f"[bold green]{new_count}[/bold green] new decisions extracted\n[bold yellow]{reinforced_count}[/bold yellow] decisions reinforced",
+                title="[bold cyan]EXTRACTION COMPLETE[/bold cyan]", border_style="cyan", expand=False
+            ))
+        else:
+            console.print(Panel(
+                "[dim]No architectural decisions found in this commit[/dim]",
+                title="[dim]EXTRACTION COMPLETE[/dim]", border_style="dim", expand=False
+            ))
+
+    except Exception as e:
+        err_log = klyd_dir / 'errors.log'
+        with open(err_log, 'a') as f:
+            f.write(f"Error extracting commit:\n{traceback.format_exc()}\n")
+        return
+
+@cli.command()
+def prepare_injection():
+    """Prepare injection file for agent sessions."""
+    from .db import get_decisions_for_files
+    from .injector import format_injection
+    
+    klyd_dir = Path('.klyd')
+    if not (klyd_dir / 'memory.db').exists():
+        return
+        
+    try:
+        with console.status("[bold cyan]Preparing injection context...[/bold cyan]", spinner="dots12"):
+            files_out = subprocess.check_output(['git', 'diff', '--cached', '--name-only'], text=True)
+            files = [f for f in files_out.strip().split('\n') if f]
+            
+            if not files:
+                with open(klyd_dir / 'injection.txt', 'w') as f:
+                    f.write('')
+                return
+                
+            db_path = str(klyd_dir / 'memory.db')
+            decisions = get_decisions_for_files(db_path, files, top_k=20)
+            
+            injection = format_injection(decisions)
+            with open(klyd_dir / 'injection.txt', 'w') as f:
+                f.write(injection)
+                
+        console.print(Panel("[green]Injection file ready at .klyd/injection.txt[/green]", border_style="green", expand=False))
+            
+    except Exception as e:
+        with open(klyd_dir / 'errors.log', 'a') as f:
+            f.write(f"Error preparing injection:\n{traceback.format_exc()}\n")
+        return
+
+@cli.command()
+def review():
+    """Review flagged conflicting decisions."""
+    from .db import get_flagged_decisions, get_active_decisions_by_module, resolve_decision
+    
+    klyd_dir = Path('.klyd')
+    db_path = klyd_dir / 'memory.db'
+    if not db_path.exists():
+        console.print("[bold red]klyd is not initialized. Run `kl init`.[/bold red]")
+        return
+
+    db_str = str(db_path)
+    flagged = get_flagged_decisions(db_str)
+    
+    if not flagged:
+        console.print(Panel(
+            "[bold green]All conflicts resolved. Memory is clean.[/bold green]",
+            title="[bold green]NO CONFLICTS[/bold green]", border_style="green", expand=False
+        ))
+        return
+
+    for i, d in enumerate(flagged):
+        console.print()
+        console.print(f"[bold cyan]Conflict {i+1} of {len(flagged)}[/bold cyan] in module: [bold white]{d['module']}[/bold white]")
+        
+        commit_ref = d.get('last_seen_commit') or "unknown commit"
+        
+        active = get_active_decisions_by_module(db_str, d['module'])
+        old_id = None
+        if active:
+            old = active[0]
+            old_id = old['id']
+            conf_color = "bold bright_green" if old['confidence'] == 'HIGH' else ("bold bright_yellow" if old['confidence'] == 'MEDIUM' else "dim white")
+            old_panel = Panel(
+                f"{old['decision']}\n\n[dim]([/dim][{conf_color}]{old['confidence']}[/{conf_color}][dim] | reinforced x{old['reinforcement_count']})[/dim]",
+                title="[bold yellow]Existing Memory[/bold yellow]",
+                border_style="yellow",
+                expand=True
+            )
+        else:
+            old_panel = Panel(
+                "\n[dim]No existing memory found.[/dim]\n",
+                title="[bold yellow]Existing Memory[/bold yellow]",
+                border_style="yellow",
+                expand=True
+            )
+
+        new_conf_color = "bold bright_green" if d['confidence'] == 'HIGH' else ("bold bright_yellow" if d['confidence'] == 'MEDIUM' else "dim white")
+        new_panel = Panel(
+            f"{d['decision']}\n\n[dim]([/dim][{new_conf_color}]{d['confidence']}[/{new_conf_color}][dim] | commit {commit_ref[:7]})[/dim]",
+            title="[bold red]New Conflicting Extraction[/bold red]",
+            border_style="red",
+            expand=True
+        )
+
+        console.print(Columns([old_panel, new_panel]))
+        
+        console.print()
+        console.print("  [bold green][ a ][/bold green] Accept new (archive old)    [bold red][ r ][/bold red] Reject new (keep old)")
+        console.print("  [bold yellow][ e ][/bold yellow] Edit manually               [bold blue][ s ][/bold blue] Skip for now")
+        console.print()
+        
+        while True:
+            choice = Prompt.ask("[bold cyan]Select action[/bold cyan]", choices=["a", "r", "e", "s"], show_choices=False).lower()
+            if choice == 's':
+                console.print("[dim]Skipped.[/dim]")
+                break
+            elif choice == 'a':
+                resolve_decision(db_str, d['id'], 'accept', old_id=old_id)
+                console.print(Panel(
+                    "[bold green]Accepted new decision. Memory updated.[/bold green]",
+                    border_style="green", expand=False
+                ))
+                break
+            elif choice == 'r':
+                resolve_decision(db_str, d['id'], 'reject')
+                console.print(Panel(
+                    "[bold red]Rejected new decision. Existing memory preserved.[/bold red]",
+                    border_style="red", expand=False
+                ))
+                break
+            elif choice == 'e':
+                new_text = click.edit(d['decision'])
+                if new_text is not None:
+                    new_text = new_text.strip()
+                    resolve_decision(db_str, d['id'], 'edit', old_id=old_id, new_text=new_text)
+                    console.print(Panel(
+                        "[bold yellow]Saved edited decision. Memory updated.[/bold yellow]",
+                        border_style="yellow", expand=False
+                    ))
+                    break
+                else:
+                    console.print("[red]Edit cancelled. Please choose an option.[/red]")
+
+@cli.command()
+def status():
+    """Show the current memory store status."""
+    klyd_dir = Path('.klyd')
+    db_path = klyd_dir / 'memory.db'
+    if not db_path.exists():
+        console.print("[bold red]klyd is not initialized. Run `kl init`.[/bold red]")
+        return
+
+    conn = sqlite3.connect(str(db_path))
+    conn.row_factory = sqlite3.Row
+    cur = conn.cursor()
+
+    cur.execute("SELECT * FROM decisions WHERE archived = 0")
+    all_decisions = [dict(r) for r in cur.fetchall()]
+    conn.close()
+
+    active = [d for d in all_decisions if d['flagged'] == 0]
+    flagged = [d for d in all_decisions if d['flagged'] == 1]
+    
+    active.sort(key=lambda x: x['reinforcement_count'], reverse=True)
+
+    table = Table(box=rich.box.SIMPLE, header_style="bold cyan", show_edge=False, padding=(0, 2))
+    table.add_column("ID", style="dim", max_width=8)
+    table.add_column("Decision", style="white")
+    table.add_column("Module", style="bold blue")
+    table.add_column("Confidence")
+    table.add_column("Event")
+    table.add_column("Reinforcements", justify="right")
+
+    for d in active:
+        conf_color = "bold bright_green" if d['confidence'] == 'HIGH' else ("bold bright_yellow" if d['confidence'] == 'MEDIUM' else "dim white")
+        conf_styled = f"[{conf_color}]{d['confidence']}[/{conf_color}]"
+        
+        event_color = "bright_blue" if d.get('event_type') == 'NEW' else ("bright_magenta" if d.get('event_type') == 'REINFORCE' else "bold bright_red")
+        event_styled = f"[{event_color}]{d.get('event_type', 'NEW')}[/{event_color}]"
+        
+        table.add_row(
+            str(d['id'])[:8],
+            d['decision'],
+            d['module'],
+            conf_styled,
+            event_styled,
+            f"x{d['reinforcement_count']}"
+        )
+    
+    if not active:
+        table.add_row("", "[dim]No active architectural decisions stored yet.[/dim]", "", "", "", "")
+
+    console.print(Panel(table, title="[bold cyan] Architectural Memory [/bold cyan]", border_style="cyan", expand=False, padding=(1, 2)))
+
+    if flagged:
+        console.print()
+        flagged_table = Table(box=rich.box.SIMPLE, show_edge=False, padding=(0, 2))
+        flagged_table.add_column("ID", style="dim", max_width=8)
+        flagged_table.add_column("Decision", style="bold white")
+        flagged_table.add_column("Module", style="bold blue")
+        flagged_table.add_column("Confidence")
+        
+        for d in flagged:
+            conf_color = "bold bright_green" if d['confidence'] == 'HIGH' else ("bold bright_yellow" if d['confidence'] == 'MEDIUM' else "dim white")
+            conf_styled = f"[{conf_color}]{d['confidence']}[/{conf_color}]"
+            
+            flagged_table.add_row(
+                str(d['id'])[:8],
+                d['decision'],
+                d['module'],
+                conf_styled
+            )
+
+        warning_panel = Panel(
+            flagged_table,
+            title="[bold white on red] NEEDS REVIEW - CONFLICTS DETECTED [/bold white on red]",
+            border_style="red",
+            expand=False,
+            padding=(1, 2)
+        )
+        console.print(warning_panel)
+
+    console.print()
+    console.print(f"[dim]Summary:[/dim] [cyan]{len(active)} active[/cyan] | [red]{len(flagged)} pending review[/red]")

klyd-0.1.0/klyd/config.py

@@ -0,0 +1,44 @@
+import json
+from pathlib import Path
+
+def get_config_path():
+    return Path('.klyd') / 'config.json'
+
+def init_config():
+    klyd_dir = Path('.klyd')
+    klyd_dir.mkdir(exist_ok=True)
+    
+    config_path = get_config_path()
+    if not config_path.exists():
+        with open(config_path, 'w') as f:
+            json.dump({}, f, indent=2)
+
+def set_config(key, value):
+    init_config()
+    config_path = get_config_path()
+    with open(config_path, 'r') as f:
+        data = json.load(f)
+    data[key] = value
+    with open(config_path, 'w') as f:
+        json.dump(data, f, indent=2)
+
+def get_config(key, default=None):
+    config_path = get_config_path()
+    if not config_path.exists():
+        return default
+    try:
+        with open(config_path, 'r') as f:
+            data = json.load(f)
+        return data.get(key, default)
+    except:
+        return default
+
+def get_all_config():
+    config_path = get_config_path()
+    if not config_path.exists():
+        return {}
+    try:
+        with open(config_path, 'r') as f:
+            return json.load(f)
+    except:
+        return {}

klyd-0.1.0/klyd/db.py

@@ -0,0 +1,124 @@
+import sqlite3
+import fnmatch
+from pathlib import Path
+
+def get_schema_path():
+    return Path(__file__).resolve().parent.parent / 'schema' / 'v1.sql'
+
+def init_db(db_path):
+    conn = sqlite3.connect(db_path)
+    schema = get_schema_path().read_text()
+    conn.executescript(schema)
+    conn.commit()
+    conn.close()
+
+def store_decision(db_path, decision_dict):
+    conn = sqlite3.connect(db_path)
+    cur = conn.cursor()
+    cur.execute('''
+        INSERT INTO decisions (decision, module, file_patterns, confidence, event_type)
+        VALUES (?, ?, ?, ?, ?)
+    ''', (
+        decision_dict['decision'],
+        decision_dict['module'],
+        decision_dict['file_patterns'],
+        decision_dict['confidence'],
+        decision_dict.get('event_type', 'NEW')
+    ))
+    conn.commit()
+    decision_id = cur.lastrowid
+    conn.close()
+    return decision_id
+
+def _match_any_file(file_patterns, file_list_str):
+    patterns = [p.strip() for p in file_patterns.split(',')]
+    files = file_list_str.split('|')
+    for f in files:
+        for p in patterns:
+            if fnmatch.fnmatch(f, p):
+                return 1
+    return 0
+
+def get_decisions_for_files(db_path, file_list, top_k=5):
+    conn = sqlite3.connect(db_path)
+    conn.row_factory = sqlite3.Row
+    conn.create_function("match_files", 2, _match_any_file)
+    
+    file_list_str = '|'.join(file_list)
+    
+    cur = conn.cursor()
+    cur.execute('''
+        SELECT * FROM decisions 
+        WHERE flagged = 0 AND archived = 0 
+        AND match_files(file_patterns, ?) = 1
+        ORDER BY (reinforcement_count * CASE confidence WHEN 'HIGH' THEN 3 WHEN 'MEDIUM' THEN 2 ELSE 1 END) DESC, last_seen_commit DESC
+        LIMIT ?
+    ''', (file_list_str, top_k))
+    
+    results = [dict(row) for row in cur.fetchall()]
+    conn.close()
+    return results
+
+def reinforce_decision(db_path, decision_id, commit_hash):
+    conn = sqlite3.connect(db_path)
+    conn.execute('''
+        UPDATE decisions 
+        SET reinforcement_count = reinforcement_count + 1, last_seen_commit = ?
+        WHERE id = ?
+    ''', (commit_hash, decision_id))
+    conn.commit()
+    conn.close()
+
+def flag_decision(db_path, decision_id):
+    conn = sqlite3.connect(db_path)
+    conn.execute('UPDATE decisions SET flagged = 1 WHERE id = ?', (decision_id,))
+    conn.commit()
+    conn.close()
+
+def archive_decision(db_path, decision_id):
+    conn = sqlite3.connect(db_path)
+    conn.execute('UPDATE decisions SET archived = 1 WHERE id = ?', (decision_id,))
+    conn.commit()
+    conn.close()
+
+def get_flagged_decisions(db_path):
+    conn = sqlite3.connect(db_path)
+    conn.row_factory = sqlite3.Row
+    cur = conn.cursor()
+    cur.execute("SELECT * FROM decisions WHERE flagged = 1 AND archived = 0")
+    res = [dict(r) for r in cur.fetchall()]
+    conn.close()
+    return res
+
+def get_active_decisions_by_module(db_path, module):
+    conn = sqlite3.connect(db_path)
+    conn.row_factory = sqlite3.Row
+    cur = conn.cursor()
+    cur.execute("SELECT * FROM decisions WHERE module = ? AND flagged = 0 AND archived = 0 ORDER BY reinforcement_count DESC", (module,))
+    res = [dict(r) for r in cur.fetchall()]
+    conn.close()
+    return res
+
+def resolve_decision(db_path, decision_id, action, old_id=None, new_text=None):
+    conn = sqlite3.connect(db_path)
+    if action == 'accept':
+        if old_id:
+            conn.execute('UPDATE decisions SET archived = 1 WHERE id = ?', (old_id,))
+        conn.execute("UPDATE decisions SET flagged = 0, confidence = 'MEDIUM' WHERE id = ?", (decision_id,))
+    elif action == 'reject':
+        conn.execute('UPDATE decisions SET archived = 1 WHERE id = ?', (decision_id,))
+    elif action == 'edit':
+        if old_id:
+            conn.execute('UPDATE decisions SET archived = 1 WHERE id = ?', (old_id,))
+        conn.execute("UPDATE decisions SET flagged = 0, confidence = 'MEDIUM', decision = ? WHERE id = ?", (new_text, decision_id))
+    conn.commit()
+    conn.close()
+
+def get_existing_decisions_for_files(file_paths: list[str]) -> list[dict]:
+    db_path = str(Path('.klyd/memory.db').resolve())
+    if not Path(db_path).exists():
+        return []
+    decisions = get_decisions_for_files(db_path, file_paths, top_k=50)
+    high_conf = [d for d in decisions if d['confidence'] == 'HIGH']
+    return [{'id': d['id'], 'decision': d['decision']} for d in high_conf[:5]]
+

klyd-0.1.0/klyd/extractor.py

@@ -0,0 +1,129 @@
+import json
+import urllib.request
+from anthropic import Anthropic
+from .db import get_existing_decisions_for_files
+
+def _call_openai_compatible(url, key, model, prompt):
+    data = json.dumps({
+        "model": model,
+        "messages": [{"role": "user", "content": prompt}]
+    }).encode('utf-8')
+    headers = {
+        "Authorization": f"Bearer {key}",
+        "Content-Type": "application/json"
+    }
+    if "openrouter.ai" in url:
+        headers["HTTP-Referer"] = "https://github.com/getKlyd/klyd"
+        headers["X-Title"] = "klyd"
+        
+    req = urllib.request.Request(url, data=data, headers=headers)
+    with urllib.request.urlopen(req) as response:
+        res = json.loads(response.read().decode('utf-8'))
+        return res['choices'][0]['message']['content']
+
+def extract_decisions(diff, commit_message, existing_decisions, config_data, model='claude-sonnet-4-6'):
+    files = []
+    for line in diff.split('\n'):
+        if line.startswith('diff --git a/'):
+            parts = line.split(' b/')
+            if len(parts) == 2:
+                files.append(parts[1].strip())
+    
+    invariants = get_existing_decisions_for_files(list(set(files)))
+    invariants_text = "\n".join([f"- [{inv['id']}] {inv['decision']}" for inv in invariants]) if invariants else "None"
+
+    prompt = f"""You are an architectural decision extractor for a software project.
+
+You will receive a git diff, a commit message, and a list of previously recorded architectural decisions for the files touched in this diff.
+
+Your job: extract the literal text of the architectural decisions that this commit clearly enacts.
+
+Architectural decisions are: data store choice, auth strategy, API boundary contracts, module responsibility assignments, dependency/library choices, error handling patterns.
+
+Rules:
+- Only record if the diff explicitly introduces, changes, or contradicts a decision
+- Do not guess. Do not infer. Only record what is clearly shown in the diff.
+- If the commit is a style fix, test update, or minor refactor with no architectural significance: return []
+- For each decision, classify as NEW (not seen before), REINFORCE (confirms an existing decision), or CONTRADICT (conflicts with an existing decision)
+- Assign confidence: HIGH (unmistakable from diff), MEDIUM (clear but could have context), LOW (possible but uncertain)
+- If this commit contradicts any of the listed invariants, set event_type to 'CONTRADICT' and add a note in the 'decision' field describing the violation. Otherwise, proceed with NEW or REINFORCE as before.
+
+Return ONLY valid JSON. No prose. No markdown. No explanation.
+- The 'decision' field must contain the exact architectural rule or invariant written in the diff, quoted verbatim if possible. Do not summarise module responsibilities. For example, prefer 'Authentication uses JWT access tokens exclusively; no server-side sessions' over 'Authentication is handled by auth.py'.
+Schema: [{{"decision": str, "module": str, "file_patterns": str, "confidence": "LOW"|"MEDIUM"|"HIGH", "event": "NEW"|"REINFORCE"|"CONTRADICT"}}]
+If no decisions: return []
+
+EXISTING DECISIONS FOR TOUCHED FILES:
+{existing_decisions}
+
+COMMIT MESSAGE:
+{commit_message}
+
+DIFF:
+{diff}
+
+Existing architectural invariants (do not violate unless explicitly instructed):
+{invariants_text}
+"""
+    try:
+        # Determine provider
+        if model.startswith('claude-') or 'api_key' in config_data and not any(k in config_data for k in ['openai_key', 'openrouter_key', 'gemini_key', 'groq_key']):
+            if 'api_key' not in config_data:
+                raise ValueError("Anthropic API key is required.")
+            client = Anthropic(api_key=config_data['api_key'])
+            response = client.messages.create(
+                model=model,
+                max_tokens=1024,
+                messages=[{"role": "user", "content": prompt}]
+            )
+            content = response.content[0].text.strip()
+        else:
+            # OpenAI compatible providers
+            if model.startswith('gpt-') or model.startswith('o1') or model.startswith('o3'):
+                if 'openai_key' not in config_data: raise ValueError("OpenAI API key missing.")
+                url, key = "https://api.openai.com/v1/chat/completions", config_data['openai_key']
+            elif model.startswith('gemini-') or model.startswith('gemma-'):
+                if 'gemini_key' not in config_data: raise ValueError("Gemini API key missing.")
+                url, key = "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions", config_data['gemini_key']
+            elif '/' in model:
+                if 'openrouter_key' not in config_data: raise ValueError("OpenRouter API key missing.")
+                url, key = "https://openrouter.ai/api/v1/chat/completions", config_data['openrouter_key']
+            elif config_data.get('groq_key'):
+                url, key = "https://api.groq.com/openai/v1/chat/completions", config_data['groq_key']
+            elif config_data.get('openai_key'):
+                url, key = "https://api.openai.com/v1/chat/completions", config_data['openai_key']
+            elif config_data.get('openrouter_key'):
+                url, key = "https://openrouter.ai/api/v1/chat/completions", config_data['openrouter_key']
+            else:
+                raise ValueError(f"No valid API key configured for model: {model}")
+                
+            content = _call_openai_compatible(url, key, model, prompt)
+            
+        # Parse output as JSON
+        content = content.strip()
+        if content.startswith('```json'):
+            content = content[7:]
+        if content.endswith('```'):
+            content = content[:-3]
+            
+        content = content.strip()
+        
+        result = json.loads(content)
+        if not isinstance(result, list):
+            return []
+        
+        normalized = []
+        for r in result:
+            event_val = r.get('event') or r.get('event_type') or 'NEW'
+            normalized.append({
+                'decision': r.get('decision', 'Unknown'),
+                'module': r.get('module', '/'),
+                'file_patterns': r.get('file_patterns', '*'),
+                'confidence': r.get('confidence', 'LOW'),
+                'event_type': event_val
+            })
+            
+        return normalized
+
+    except Exception as e:
+        raise

klyd-0.1.0/klyd/hooks.py

@@ -0,0 +1,40 @@
+import os
+import shutil
+import stat
+from pathlib import Path
+
+def get_template_path(hook_name):
+    # Try to find the hooks directory relative to this file
+    base_dir = Path(__file__).resolve().parent.parent
+    hook_path = base_dir / 'hooks' / f"{hook_name}.sh"
+    return hook_path
+
+def install_hooks():
+    git_dir = Path('.git')
+    if not git_dir.is_dir():
+        raise RuntimeError("Not a git repository. Please run in the root of a git repo.")
+
+    git_hooks_dir = git_dir / 'hooks'
+    git_hooks_dir.mkdir(exist_ok=True)
+
+    for hook in ['post-commit', 'pre-commit']:
+        src = get_template_path(hook)
+        if not src.exists():
+            raise RuntimeError(f"Hook template not found: {src}")
+        
+        dest = git_hooks_dir / hook
+        shutil.copy2(src, dest)
+        
+        # chmod +x
+        dest.chmod(dest.stat().st_mode | stat.S_IEXEC)
+
+def uninstall_hooks():
+    git_dir = Path('.git')
+    if not git_dir.is_dir():
+        return
+        
+    git_hooks_dir = git_dir / 'hooks'
+    for hook in ['post-commit', 'pre-commit']:
+        dest = git_hooks_dir / hook
+        if dest.exists() and "klyd" in dest.read_text():
+            dest.unlink()

klyd-0.1.0/klyd/injector.py

@@ -0,0 +1,18 @@
+def format_injection(decisions):
+    if not decisions:
+        return ""
+
+    lines = [
+        "[klyd] Architectural decisions governing files in this session:\n"
+    ]
+    
+    for i, d in enumerate(decisions, 1):
+        mod = f"[{d['module']}]"
+        conf = f"{d['confidence']} confidence"
+        count = f"confirmed {d['reinforcement_count']} times"
+        dec = f"{d['decision']}."
+        lines.append(f"{i}. {mod} {dec} ({conf}, {count})")
+        
+    lines.append("\nDo not contradict these decisions unless the user explicitly instructs you to change them.")
+    
+    return "\n".join(lines)

klyd-0.1.0/klyd.egg-info/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: klyd
+Version: 0.1.0
+Summary: A CLI tool that wraps coding agents via git hooks to inject architectural memory.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click
+Requires-Dist: anthropic
+Dynamic: license-file
+
+<center>
+
+```ascii
+
+           ▄█   ▄█▄            ▄█                 ▄██   ▄             ████████▄            
+          ███ ▄███▀           ███                 ███   ██▄           ███   ▀███           
+          ███▐██▀             ███                 ███▄▄▄███           ███    ███           
+         ▄█████▀              ███                 ▀▀▀▀▀▀███           ███    ███           
+        ▀▀█████▄              ███                 ▄██   ███           ███    ███           
+          ███▐██▄             ███                 ███   ███           ███    ███           
+          ███ ▀███▄           ███▌    ▄           ███   ███           ███   ▄███           
+          ███   ▀█▀           █████▄▄██            ▀█████▀            ████████▀            
+          ▀                   ▀                                                            
+
+```
+</center>
+
+install → klyd init → klyd config --api-key sk-... → klyd run aider
+
+## Quickstart
+
+```bash
+# 1. Install
+pip install .
+
+# 2. Initialize in your repo
+cd your-project
+klyd init
+
+# 3. Configure an API Key
+# Anthropic (Default)
+klyd config --api-key sk-ant-...
+
+# OR OpenAI
+klyd config --openai-key sk-proj-... --model gpt-4o
+
+# OR OpenRouter
+klyd config --openrouter-key sk-or-... --model openrouter/auto
+
+# OR Gemini
+klyd config --gemini-key AIza... --model gemini-1.5-pro
+
+# OR Groq
+klyd config --groq-key gsk_... --model llama3-8b-8192
+
+# 4. Use your agent as normal
+klyd run aider
+```
+
+Decisions will automatically populate after you make commits. Review flagged contradictions using `klyd review`. Check current status with `klyd status`.

klyd-0.1.0/klyd.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+AGENTS.md.txt
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+hooks/post-commit.sh
+hooks/pre-commit.sh
+klyd/__init__.py
+klyd/cli.py
+klyd/config.py
+klyd/db.py
+klyd/extractor.py
+klyd/hooks.py
+klyd/injector.py
+klyd.egg-info/PKG-INFO
+klyd.egg-info/SOURCES.txt
+klyd.egg-info/dependency_links.txt
+klyd.egg-info/entry_points.txt
+klyd.egg-info/requires.txt
+klyd.egg-info/top_level.txt

klyd-0.1.0/klyd.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

klyd-0.1.0/klyd.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kl = klyd.cli:cli

klyd-0.1.0/klyd.egg-info/requires.txt

@@ -0,0 +1,2 @@
+click
+anthropic

klyd-0.1.0/klyd.egg-info/top_level.txt

@@ -0,0 +1 @@
+klyd

klyd-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "klyd"
+version = "0.1.0"
+description = "A CLI tool that wraps coding agents via git hooks to inject architectural memory."
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "click",
+    "anthropic"
+]
+
+[tool.setuptools.packages.find]
+include = ["klyd", "klyd.*"]
+
+[project.scripts]
+kl = "klyd.cli:cli"

klyd-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+