konman 1.0.0__py3-none-any.whl

konman/__init__.py

@@ -0,0 +1,2 @@
+# conman: The LLM-Agnostic Context Manager Engine
+__version__ = "1.0.0"

konman/cli.py

@@ -0,0 +1,495 @@
+import sys
+import glob
+import os
+import click
+from pathlib import Path
+from datetime import datetime
+from ruamel.yaml import YAML
+from konman.engine import ContextEngine
+from konman.config import (
+    inject_antigravity_hooks, inject_claude_code_adapters, inject_codex_adapters,
+    inject_vsc_copilot_adapters, inject_cursor_adapters, inject_kiro_adapters,
+    save_global_api_credentials, load_global_api_credentials
+)
+
+class ConmanTopLevelGroup(click.Group):
+    def format_help(self, ctx, formatter):
+        formatter.write_usage(ctx.command_path, "[COMMAND] [OPTIONS]")
+        formatter.write_paragraph()
+        formatter.write_text("🧠 konman (Context Manager): Automated, LLM-Agnostic Codebase Context Engine.")
+        
+        commands = self.list_commands(ctx)
+        core_cmds = [c for c in commands if c in ["init", "setup", "sync", "state", "record", "resolve", "check", "config", "setup-hooks", "disable-hooks"]]
+        pipe_cmds = [c for c in commands if c in ["tail", "mine", "extract", "handoff", "hook", "mcp"]]
+        
+        if core_cmds:
+            with formatter.section("🎯 Core Workspace Management Commands"):
+                formatter.write_dl([(c, self.get_command(ctx, c).get_short_help_str()) for c in core_cmds])
+        if pipe_cmds:
+            with formatter.section("🔌 Context Extraction & Lifecycle Pipelines"):
+                formatter.write_dl([(c, self.get_command(ctx, c).get_short_help_str()) for c in pipe_cmds])
+        self.format_options(ctx, formatter)
+
+@click.group(cls=ConmanTopLevelGroup)
+def main():
+    """konman (Context Manager): Automated, LLM-Agnostic Context Mapping Engine."""
+    pass
+
+@main.command()
+@click.option("--dir", default=".", help="Target project root directory location.")
+def init(dir):
+    """Scaffold a new .context data graph directory inside a code repository."""
+    engine = ContextEngine(dir)
+    engine.init_folders()
+    click.echo(f"✨ Initialized .context folder array framework inside: {engine.base_dir}")
+
+@main.group(name="setup")
+def setup_group():
+    """Inject specialized adapter workspace configurations for your preferred dev tool."""
+    pass
+
+@setup_group.command(name="antigravity")
+@click.option("--dir", default=".", help="Target project root directory location.")
+def setup_antigravity(dir):
+    """Inject background tracking hooks and local server pointers into Antigravity configurations."""
+    engine = ContextEngine(dir)
+    engine.init_folders()
+    inject_antigravity_hooks(dir)
+    engine.compile_agents_md()
+    click.echo("🚀 Injected system bindings across Antigravity successfully.")
+
+@setup_group.command(name="claude-code")
+@click.option("--dir", default=".", help="Target project root directory location.")
+def setup_claude_code(dir):
+    """Generate localized CLAUDE.md routing pointers for Claude Code CLI."""
+    engine = ContextEngine(dir)
+    engine.init_folders()
+    inject_claude_code_adapters(dir)
+    engine.compile_agents_md()
+    click.echo("🚀 Injected system bindings across Claude Code successfully.")
+
+@setup_group.command(name="codex")
+@click.option("--dir", default=".", help="Target project root directory location.")
+def setup_codex(dir):
+    """Deploy workspace directory tracking layouts matching Codex specification tracks."""
+    engine = ContextEngine(dir)
+    engine.init_folders()
+    inject_codex_adapters(dir)
+    engine.compile_agents_md()
+    click.echo("🚀 Injected system bindings across Codex successfully.")
+
+@setup_group.command(name="vsc-copilot")
+@click.option("--dir", default=".", help="Target project root directory location.")
+def setup_vsc_copilot(dir):
+    """Generate .github/copilot-instructions.md configuration files for VS Code Copilot."""
+    engine = ContextEngine(dir)
+    engine.init_folders()
+    inject_vsc_copilot_adapters(dir)
+    engine.compile_agents_md()
+    click.echo("🚀 Injected system bindings across VS Code Copilot successfully.")
+
+@setup_group.command(name="cursor")
+@click.option("--dir", default=".", help="Target project root directory location.")
+def setup_cursor(dir):
+    """Generate .cursor/rules/ global metadata adapters for Cursor IDE."""
+    engine = ContextEngine(dir)
+    engine.init_folders()
+    inject_cursor_adapters(dir)
+    engine.compile_agents_md()
+    click.echo("🚀 Injected system bindings across Cursor successfully.")
+
+@setup_group.command(name="kiro")
+@click.option("--dir", default=".", help="Target project root directory location.")
+def setup_kiro(dir):
+    """Deploy workspace directory configurations for Kiro agent steering engines."""
+    engine = ContextEngine(dir)
+    engine.init_folders()
+    inject_kiro_adapters(dir)
+    engine.compile_agents_md()
+    click.echo("🚀 Injected system bindings across Kiro successfully.")
+
+@main.command()
+@click.option("--dir", default=".", help="Target project root directory location.")
+def sync(dir):
+    """Force cross-dependency checks, process structural changes, and refresh AGENTS.md."""
+    engine = ContextEngine(dir)
+    stale_updates = engine.process_staleness_propagation()
+    engine.compile_agents_md()
+    click.echo(f"🔄 Graph database synchronization complete. Flagged {stale_updates} decisions for review updates.")
+
+@main.command()
+@click.option("--dir", default=".", help="Target project root directory location.")
+def check(dir):
+    """Audit the local context data layout for unresolved reviews or stale dependency tracks."""
+    engine = ContextEngine(dir)
+    violations = engine.check_graph_validity()
+    if violations:
+        click.echo("⚠️  CONTEXT INTEGRITY VALIDATION FAILED:")
+        for v in violations:
+            click.echo(f"  ❌ {v}")
+        sys.exit(1)
+    click.echo("🟢 Context mapping validated. No unresolved structural anomalies located.")
+    sys.exit(0)
+
+@main.command()
+@click.option("--dir", default=".", help="Target project root directory location.")
+def state(dir):
+    """Render an interactive high-level dashboard map of current codebase architectural contexts."""
+    engine = ContextEngine(dir)
+    yaml = YAML()
+    if not engine.ctx_dir.exists():
+        click.echo("❌ No context database found in this workspace directory. Run 'konman init' first.")
+        return
+
+    click.echo("\n======================================================================")
+    click.echo(f"📊 KONMAN CONTEXT DATABASE STATUS MATRIX: {engine.base_dir.name.upper()}")
+    click.echo("======================================================================\n")
+
+    click.echo("📌 ACTIVE SYSTEM ARCHITECTURAL REQUIREMENTS:")
+    req_dir = engine.ctx_dir / "requirements"
+    has_reqs = False
+    if req_dir.exists():
+        for p in req_dir.glob("*.yaml"):
+            with open(p, "r", encoding="utf-8") as f:
+                r = yaml.load(f)
+                if r and r.get("status") == "active":
+                    has_reqs = True
+                    click.echo(f"  ├─ {r.get('id')} [{r.get('kind').upper()}]: {r.get('statement')}")
+                    if r.get("why"):
+                        click.echo(f"  │  └── 🧠 Why: {r.get('why')}")
+    if not has_reqs:
+        click.echo("  └─ (No active requirements mapped to this repository yet)")
+
+    click.echo("\n🧠 RECENT ARCHITECTURAL TRADEOFF DECISIONS:")
+    dec_dir = engine.ctx_dir / "decisions"
+    has_decs = False
+    if dec_dir.exists():
+        for p in dec_dir.glob("*.yaml"):
+            with open(p, "r", encoding="utf-8") as f:
+                d = yaml.load(f)
+                if d:
+                    has_decs = True
+                    status_indicator = "🟢 [ACTIVE]" if d.get("status") == "active" else "⚠️  [REVIEW]"
+                    click.echo(f"  ├─ {d.get('id')} Chosen: {d.get('chosen').upper()} -- {status_indicator}")
+                    if d.get("reason"):
+                        click.echo(f"  │  ├── Rationale: {d.get('reason')}")
+                    rejected_opts = [c.get("object") for c in d.get("considered", []) if c.get("verdict") == "rejected"]
+                    if rejected_opts:
+                        click.echo(f"  │  └── ❌ Rejected Options: {', '.join(rejected_opts)}")
+    if not has_decs:
+        click.echo("  └─ (No architectural tradeoff items logged in database layout)")
+
+    click.echo("\n🔌 UNTRACKED BACKGROUND DATA CAPTURE QUEUE:")
+    raw_dir = engine.ctx_dir / ".raw"
+    untracked_files = [f.name for f in raw_dir.iterdir() if f.is_file()] if raw_dir.exists() else []
+    if untracked_files:
+        click.echo(f"  ⚠️  [PENDING] There are {len(untracked_files)} raw context history log packet files waiting.")
+        click.echo("     👉 Run 'konman extract' to automatically parse and promote them to your database.")
+    else:
+        click.echo("  🟢 No untracked history data packets currently idling inside your background raw queue pipes.")
+    click.echo("\n======================================================================\n")
+
+@main.command()
+@click.option("--type", "-t", required=True, type=click.Choice(["requirement", "decision", "boundary"]), help="The type of context entity to create.")
+@click.option("--id", "-i", required=True, help="Unique identifier (e.g., R-101, D-002, B-001).")
+@click.option("--dir", default=".", help="Target project root directory location.")
+def record(type, id, dir):
+    """Manually record an entity (Requirement, Decision, Boundary) into the data graph."""
+    engine = ContextEngine(dir)
+    engine.init_folders()
+    yaml = YAML()
+    yaml.preserve_quotes = True
+    timestamp = datetime.now().strftime("%Y-%m-%d")
+
+    if type == "requirement":
+        statement = click.prompt("📋 Enter the core Requirement statement")
+        kind = click.prompt("🏷️  Kind", type=click.Choice(["hard", "preference"]), default="hard")
+        why = click.prompt("🧠 Why is this requirement needed?", default="")
+        payload = {"id": id, "statement": statement, "kind": kind, "priority": "high" if kind == "hard" else "medium", "source": {"who": "human:dev", "when": timestamp}, "why": why if why else None, "status": "active"}
+        target_path = engine.ctx_dir / "requirements" / f"{id}.yaml"
+    elif type == "decision":
+        chosen = click.prompt("✅ Chosen candidate/object name")
+        mode = click.prompt("🛠️  Decision mode", type=click.Choice(["compared", "default", "forced", "taste"]), default="compared")
+        reason = click.prompt("🧠 Reason or tradeoff summary", default="")
+        considered = []
+        if mode == "compared":
+            while click.confirm("🔄 Would you like to record a rejected alternative option?"):
+                alt_name = click.prompt("❌ Rejected object/technology name")
+                fail_prop = click.prompt(f"🔍 Which property caused {alt_name} to fail?")
+                fail_req = click.prompt(f"🔗 Which Requirement ID did it violate?")
+                considered.append({"object": alt_name, "properties": [{"key": fail_prop, "value": True, "evidence": "documented"}], "evaluations": [{"req": fail_req, "result": "fail", "via": fail_prop}], "verdict": "rejected"})
+        considered.append({"object": chosen, "properties": [], "evaluations": [], "verdict": "selected"})
+        payload = {"id": id, "chosen": chosen, "mode": mode, "decided": {"who": "human:dev", "when": timestamp}, "considered": considered, "reason": reason if reason else None, "status": "active"}
+        target_path = engine.ctx_dir / "decisions" / f"{id}.yaml"
+    elif type == "boundary":
+        path_str = click.prompt("📁 Enter the codebase file path to protect")
+        why = click.prompt("🧠 Why must this boundary be enforced?", default="")
+        payload = {"path": path_str, "rule": "no_edit_without_approval", "why": why, "constrains": []}
+        target_path = engine.ctx_dir / "boundaries.yaml"
+
+    with open(target_path, "w", encoding="utf-8") as f:
+        yaml.dump(payload, f)
+    engine.compile_agents_md()
+    click.echo(f"🎉 Successfully saved and synced {id} to the context database layer!")
+
+@main.command()
+@click.argument("id")
+@click.option("--dir", default=".", help="Target project root directory location.")
+def resolve(id, dir):
+    """Interactively reconcile and repair a decision node flagged with review states."""
+    engine = ContextEngine(dir)
+    yaml = YAML()
+    yaml.preserve_quotes = True
+    target_path = engine.ctx_dir / "decisions" / f"{id}.yaml"
+    
+    if not target_path.exists():
+        click.echo(f"❌ Error: No decision node with ID '{id}' located inside the database matrix.")
+        return
+
+    with open(target_path, "r", encoding="utf-8") as f:
+        d = yaml.load(f)
+
+    click.echo(f"\n🛠️  Reconciling Stale State Flag for Decision: {id}")
+    new_reason = click.prompt("🧠 Enter the updated tradeoff justification for keeping this choice")
+    
+    if click.confirm("🟢 Reset status back to 'active' and clear git blocking flags?"):
+        d["reason"] = new_reason
+        d["status"] = "active"
+        with open(target_path, "w", encoding="utf-8") as f:
+            yaml.dump(d, f)
+        engine.compile_agents_md()
+        click.echo(f"🎉 Graph healed! Decision '{id}' is now active. Git hooks unblocked.")
+
+@main.command()
+@click.option("--count", "-c", default=10, help="Number of historical commit messages back to process.")
+@click.option("--dir", default=".", help="Target project root directory location.")
+def mine(count, dir):
+    """Parse local Git repository commit messages history trail to capture contextual explanation data logs."""
+    engine = ContextEngine(dir)
+    click.echo(f"⛏️  Mining the last {count} git commits for architectural reasoning clues...")
+    extracted = engine.mine_git_history(count)
+    click.echo(f"🎉 History archeology complete! Extracted [{extracted}] raw context dumps into .context/.raw/")
+
+@main.command()
+@click.option("--dir", default=".", help="Target project root directory location.")
+def tail(dir):
+    """Scan and merge deeply nested VS Code Copilot extension logs into a continuous history."""
+    engine = ContextEngine(dir)
+    raw_dir = engine.ctx_dir / ".raw"
+    user_home = Path.home()
+    search_pattern = os.path.join(user_home, "AppData", "Roaming", "Code", "logs", "**", "GitHub.copilot-chat", "GitHub Copilot Chat.log")
+    
+    log_files = glob.glob(search_pattern, recursive=True)
+    valid_files = [f for f in log_files if os.path.isfile(f)]
+    if not valid_files:
+        click.echo("⚠️ No active background Copilot log streams detected.")
+        return
+
+    latest_log = max(valid_files, key=os.path.getmtime)
+    try:
+        with open(latest_log, "r", encoding="utf-8", errors="ignore") as f:
+            new_log_content = f.read().strip()
+        if not new_log_content:
+            return
+
+        history_file = raw_dir / "copilot_history.log"
+        with open(history_file, "w", encoding="utf-8") as out:
+            out.write(new_log_content)
+        click.echo(f"🎉 Successfully pulled previous prompts into: .context/.raw/copilot_history.log")
+    except Exception as e:
+        click.echo(f"❌ Error: {str(e)}")
+
+@main.command()
+@click.option("--api-key", envvar="OPENAI_API_KEY", help="Your OpenAI API credentials key parameter.")
+@click.option("--model", default="gpt-4o-mini", help="Target LLM model selector pass value.")
+@click.option("--dir", default=".", help="Target project root directory location.")
+def extract(api_key, model, dir):
+    """Passively scan untracked file histories inside .raw/ and use an LLM to distill YAML nodes automatically."""
+    if not api_key:
+        global_cfg = load_global_api_credentials()
+        if global_cfg and global_cfg.get("api_key"):
+            api_key = global_cfg.get("api_key")
+        elif os.environ.get("OPENAI_API_KEY"):
+            api_key = os.environ.get("OPENAI_API_KEY")
+        else:
+            click.echo("❌ Error: No API credentials located. Configure your global key using: konman config -k <key>")
+            sys.exit(1)
+
+    engine = ContextEngine(dir)
+    history_file = engine.ctx_dir / ".raw" / "copilot_history.log"
+    if not history_file.exists():
+        click.echo("😴 No untracked history file found inside .context/.raw/. Run 'konman tail' first.")
+        return
+
+    click.echo(f"🤖 Shipping transcript data stream over to LLM [{model}] for semantic processing...")
+    with open(history_file, "r", encoding="utf-8", errors="ignore") as f:
+        raw_text = f.read()[:15000]
+        
+    structured_json_str = engine.execute_llm_distillation(raw_text, api_key, model)
+    try:
+        import json
+        extracted_data = json.loads(structured_json_str)
+        yaml = YAML()
+        
+        for r in extracted_data.get("requirements", []):
+            r["status"] = "active"
+            r["source"] = {"who": f"llm:{model}", "when": datetime.now().strftime("%Y-%m-%d")}
+            with open(engine.ctx_dir / "requirements" / f"{r['id']}.yaml", "w", encoding="utf-8") as out:
+                yaml.dump(r, out)
+            click.echo(f"   ✨ Synthesized Requirement Node: {r['id']}")
+
+        for d in extracted_data.get("decisions", []):
+            d["status"] = "active"
+            d["decided"] = {"who": f"llm:{model}", "when": datetime.now().strftime("%Y-%m-%d")}
+            d["considered"] = [{"object": d["chosen"], "properties": [], "evaluations": [], "verdict": "selected"}]
+            with open(engine.ctx_dir / "decisions" / f"{d['id']}.yaml", "w", encoding="utf-8") as out:
+                yaml.dump(d, out)
+            click.echo(f"   ✨ Synthesized Decision Node: {d['id']}")
+            
+        engine.compile_agents_md()
+        click.echo("🎉 Semantic code extraction pass complete!")
+    except Exception as e:
+        click.echo(f"❌ Failed to parse LLM payload responses: {str(e)}")
+
+@main.command(name="handoff")
+@click.argument("previous_tool")
+@click.argument("next_tool")
+@click.option("--dir", default=".", help="Target project root directory location.")
+def handoff(previous_tool, next_tool, dir):
+    """Compile context package for the next model and instantly hot-swap active project rules adapters."""
+    engine = ContextEngine(dir)
+    click.echo(f"📦 Initiating seamless context transit migration from [{previous_tool}] to [{next_tool}]...")
+    
+    if next_tool == "antigravity":
+        inject_antigravity_hooks(dir)
+    elif next_tool == "claude-code":
+        inject_claude_code_adapters(dir)
+    elif next_tool == "vsc-copilot":
+        inject_vsc_copilot_adapters(dir)
+    elif next_tool == "cursor":
+        inject_cursor_adapters(dir)
+    elif next_tool == "kiro":
+        inject_kiro_adapters(dir)
+    else:
+        click.echo(f"⚠️ Unknown destination adapter environment: {next_tool}. Configuration skipped.")
+        
+    engine.compile_agents_md()
+    click.echo(f"🎉 Context migration completed successfully! AGENTS.md recompiled matching {next_tool} guidelines.")
+
+@main.command(name="config")
+@click.option("--api-key", "-k", help="Your developer platform API credential string.")
+@click.option("--provider", "-p", default="openai", type=click.Choice(["openai"]), help="Target interface platform router configuration baseline.")
+def config_command(api_key, provider):
+    """Securely register or inspect global developer LLM API configurations across your system environment."""
+    if not api_key:
+        current_cfg = load_global_api_credentials()
+        if current_cfg and current_cfg.get("api_key"):
+            click.echo(f"🔒 konman Core Configuration: Active Provider [{current_cfg.get('provider').upper()}]")
+            click.echo(f"   Stored Credential Token: sk-...{current_cfg.get('api_key')[-4:]}")
+        else:
+            click.echo("❌ Error: No global key configured. Register using: konman config -k <key>")
+        return
+    saved_path = save_global_api_credentials(api_key, provider)
+    click.echo(f"🚀 Successfully locked structural credentials globally inside profile path: {saved_path}")
+
+@main.command()
+@click.option("--event", required=True, help="Triggering lifecycle event tracking property identifier.")
+def hook(event):
+    """Passive fail-open streaming logging trap execution pipeline configuration interface."""
+    try:
+        raw_payload = sys.stdin.read() if not sys.stdin.isatty() else ""
+        if raw_payload:
+            raw_dir = Path(".context/.raw")
+            if raw_dir.exists():
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                with open(raw_dir / f"{event}_{timestamp}.json", "w", encoding="utf-8") as f:
+                    f.write(raw_payload)
+    except Exception:
+        sys.exit(0)
+    sys.exit(0)
+
+@main.command()
+def mcp():
+    """Interactive protocol listener layer matching baseline standard MCP JSON-RPC routing frameworks."""
+    click.echo("Context Manager MCP Engine Online Active Terminal State loop placeholder.", err=True)
+    sys.exit(0)
+
+@main.command()
+@click.option("--dir", default=".", help="Target project root directory location.")
+def disable_hooks(dir):
+    """Remove and disable the konman validation guardrail from your local Git pre-commit workflow."""
+    engine = ContextEngine(dir)
+    pre_commit_file = Path(dir) / ".git" / "hooks" / "pre-commit"
+    
+    if not pre_commit_file.parent.exists():
+        click.echo("❌ Error: Target folder is not a valid Git repository root.")
+        sys.exit(1)
+        
+    if not pre_commit_file.exists():
+        click.echo("✨ No active Git pre-commit hooks found. Nothing to disable.")
+        return
+        
+    try:
+        # Read the file to see if it belongs to konman or a third-party tool
+        with open(pre_commit_file, "r", encoding="utf-8") as f:
+            content = f.read()
+            
+        if "konman check" in content:
+            # Safely delete the konman hook script file
+            pre_commit_file.unlink()
+            click.echo("🛑 Successfully removed 'konman check' guardrails from your Git pre-commit lifecycle hooks.")
+        else:
+            click.echo("⚠️  The active pre-commit file belongs to a third-party tool. Skipping removal to avoid data loss.")
+            click.echo("👉 If you want to disable it manually, edit or delete: .git/hooks/pre-commit")
+            
+    except Exception as e:
+        click.echo(f"❌ Failed to disable pre-commit script loop: {str(e)}")
+        sys.exit(1)
+
+@main.command(name="setup-hooks")
+@click.option("--dir", default=".", help="Target project root directory location.")
+def setup_hooks(dir):
+    """Inject a pre-configured verification shell script loop directly into your local Git workflow gates."""
+    engine = ContextEngine(dir)
+    
+    # Safely resolve git directory locations using pathlib attributes
+    git_dir = Path(dir).resolve() / ".git"
+    
+    if not git_dir.exists():
+        click.echo("❌ Error: Target folder is not a valid Git repository root. Run 'git init' first.")
+        sys.exit(1)
+        
+    git_hooks_dir = git_dir / "hooks"
+    git_hooks_dir.mkdir(exist_ok=True)
+    
+    pre_commit_file = git_hooks_dir / "pre-commit"
+    
+    # Standard shell script trap directing validation steps to 'konman check'
+    hook_content = (
+        "#!/bin/sh\n"
+        "echo '🔍 [Konman] Verifying active codebase context data graph integrity...'\n"
+        "konman check\n"
+        "if [ $? -ne 0 ]; then\n"
+        "    echo '❌ [Konman] Git commit aborted. Fix outstanding stale context files or clear needs_review tags first.'\n"
+        "    exit 1\n"
+        "fi\n"
+    )
+    
+    try:
+        # Enforce UTF-8 write streams to bypass Windows locale codec blockages
+        with open(pre_commit_file, "w", encoding="utf-8", newline="\n") as f:
+            f.write(hook_content)
+            
+        # Grant execution permissions explicitly on macOS/Linux/Git Bash environments
+        if os.name != "nt":
+            import stat
+            current_mode = os.stat(pre_commit_file).st_mode
+            os.chmod(pre_commit_file, current_mode | stat.S_IEXEC)
+            
+        click.echo("🚀 Successfully linked 'konman check' into .git/hooks/pre-commit gate runner!")
+    except Exception as e:
+        click.echo(f"❌ Failed to write Git pre-commit script hook: {str(e)}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

konman/config.py

@@ -0,0 +1,146 @@
+import os
+import json
+from pathlib import Path
+from datetime import datetime
+
+def inject_antigravity_hooks(target_dir: str):
+    """Register konman directly inside the environment settings matching Antigravity schemas."""
+    home = Path.home()
+    ag_configs = [
+        home / ".gemini/antigravity/mcp_config.json",
+        home / ".gemini/config/mcp_config.json"
+    ]
+    
+    mcp_injection = {
+        "command": "konman",
+        "args": ["mcp"],
+        "env": {"PYTHONUNBUFFERED": "1"}
+    }
+
+    for path in ag_configs:
+        if path.parent.exists():
+            config_data = {}
+            if path.exists():
+                try:
+                    with open(path, "r", encoding="utf-8") as f:
+                        config_data = json.load(f)
+                except Exception:
+                    config_data = {}
+            
+            if "mcpServers" not in config_data:
+                config_data["mcpServers"] = {}
+                
+            config_data["mcpServers"]["konman"] = mcp_injection
+            with open(path, "w", encoding="utf-8") as f:
+                json.dump(config_data, f, indent=2)
+
+    hooks_dir = Path(target_dir) / ".agents"
+    hooks_dir.mkdir(exist_ok=True)
+    hooks_file = hooks_dir / "hooks.json"
+    
+    hooks_payload = {
+        "hooks": [
+            {"event": "UserPromptSubmit", "command": "konman", "args": ["hook", "--event", "UserPromptSubmit"], "fail_mode": "open"},
+            {"event": "SessionEnd", "command": "konman", "args": ["hook", "--event", "SessionEnd"], "fail_mode": "open"}
+        ]
+    }
+    with open(hooks_file, "w", encoding="utf-8") as f:
+        json.dump(hooks_payload, f, indent=2)
+
+def inject_claude_code_adapters(target_dir: str):
+    """Enforce context mapping pointers layout compatible with Claude Code interface files."""
+    base = Path(target_dir)
+    claude_md = base / "CLAUDE.md"
+    if not claude_md.exists():
+        with open(claude_md, "w", encoding="utf-8") as f:
+            f.write(
+                "# CLAUDE.md Configuration Instructions\n\n"
+                "System instructions and constraints for this repository are centralized.\n"
+                "Please read the structural system rules from **AGENTS.md** before processing builds.\n"
+            )
+
+def inject_codex_adapters(target_dir: str):
+    """Appends configurations to guarantee cross-compatibility across Codex runtime tracks."""
+    base = Path(target_dir)
+    codex_hook_dir = base / ".codex"
+    codex_hook_dir.mkdir(exist_ok=True)
+
+def inject_vsc_copilot_adapters(target_dir: str):
+    """Generates custom context integration patterns for VS Code Copilot."""
+    base = Path(target_dir)
+    github_dir = base / ".github"
+    github_dir.mkdir(exist_ok=True)
+    
+    copilot_md = github_dir / "copilot-instructions.md"
+    if not copilot_md.exists():
+        with open(copilot_md, "w", encoding="utf-8") as f:
+            f.write(
+                "# VS Code Copilot Workspace Instructions\n\n"
+                "This project uses a codebase context management tool framework.\n"
+                "Before altering files or architecture paths, look up hard architectural boundary constraints inside **AGENTS.md**.\n"
+            )
+
+def inject_cursor_adapters(target_dir: str):
+    """Generates custom system rules `.mdc` file layers with dynamic globs inside Cursor spaces."""
+    base = Path(target_dir)
+    cursor_rules_dir = base / ".cursor" / "rules"
+    cursor_rules_dir.mkdir(parents=True, exist_ok=True)
+    
+    conman_mdc = cursor_rules_dir / "konman-context.mdc"
+    if not conman_mdc.exists():
+        with open(conman_mdc, "w", encoding="utf-8") as f:
+            f.write(
+                "---\n"
+                "description: Enforce global first-principles architectural constraints mapped by konman\n"
+                "globs: \"*\"\n"
+                "alwaysApply: true\n"
+                "---\n\n"
+                "# 📌 Cursor Workspace Execution Directive\n\n"
+                "This codebase relies on version-controlled semantic context metadata blocks.\n"
+                "Before processing code modifications, you MUST verify active requirements, tradeoffs, and protected path criteria inside **AGENTS.md**.\n"
+            )
+
+def inject_kiro_adapters(target_dir: str):
+    """Deploys explicit semantic context files matching Kiro agent system steering schemas."""
+    base = Path(target_dir)
+    kiro_steering_dir = base / ".kiro" / "steering"
+    kiro_steering_dir.mkdir(parents=True, exist_ok=True)
+    
+    kiro_md = kiro_steering_dir / "context_steering.md"
+    if not kiro_md.exists():
+        with open(kiro_md, "w", encoding="utf-8") as f:
+            f.write(
+                "# 🚀 Kiro System Steering Context Map\n\n"
+                "This file routes background project intent to the Kiro model loop engine.\n"
+                "Please cross-reference constraints with the master mapping index generated at **AGENTS.md**.\n"
+            )
+
+def save_global_api_credentials(api_key: str, provider: str = "openai") -> str:
+    """Persists API credentials globally inside the user's home configuration directory path."""
+    config_dir = Path.home() / ".config" / "konman"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    config_file = config_dir / "config.json"
+    
+    payload = {
+        "provider": provider,
+        "api_key": api_key,
+        "configured_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    }
+    
+    with open(config_file, "w", encoding="utf-8") as f:
+        json.dump(payload, f, indent=2)
+        
+    if os.name != "nt":
+        os.chmod(config_file, 0o600)
+    return str(config_file)
+
+def load_global_api_credentials() -> dict:
+    """Loads globally mapped authentication parameters from the home configuration directory."""
+    config_file = Path.home() / ".config" / "konman" / "config.json"
+    if config_file.exists():
+        try:
+            with open(config_file, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception:
+            return {}
+    return {}

konman/engine.py

@@ -0,0 +1,177 @@
+import os
+import glob
+from pathlib import Path
+from ruamel.yaml import YAML
+
+class ContextEngine:
+    def __init__(self, target_dir: str = "."):
+        self.base_dir = Path(target_dir).resolve()
+        self.ctx_dir = self.base_dir / ".context"
+        self.yaml = YAML()
+        self.yaml.preserve_quotes = True
+
+    def init_folders(self):
+        """Scaffold the .context storage layout matrix folder database."""
+        folders = [
+            "requirements", "decisions", "objects", 
+            "state/history", ".raw", "questions"
+        ]
+        for f in folders:
+            (self.ctx_dir / f).mkdir(parents=True, exist_ok=True)
+            
+        manifest_path = self.ctx_dir / "manifest.yaml"
+        if not manifest_path.exists():
+            with open(manifest_path, "w", encoding="utf-8") as f:
+                self.yaml.dump({
+                    "schema_version": "1.0.0",
+                    "tool_name": "konman"
+                }, f)
+
+    def process_staleness_propagation(self) -> int:
+        """Finds any decision using a superseded requirement and flags it instantly."""
+        req_dir = self.ctx_dir / "requirements"
+        dec_dir = self.ctx_dir / "decisions"
+        if not req_dir.exists() or not dec_dir.exists():
+            return 0
+
+        stale_reqs = set()
+        for p in req_dir.glob("*.yaml"):
+            with open(p, "r", encoding="utf-8") as f:
+                data = self.yaml.load(f)
+                if data and data.get("status") in ["superseded", "disproven"]:
+                    stale_reqs.add(data.get("id"))
+
+        updated_count = 0
+        for p in dec_dir.glob("*.yaml"):
+            with open(p, "r", encoding="utf-8") as f:
+                dec_data = self.yaml.load(f)
+            
+            if not dec_data or dec_data.get("status") == "needs_review":
+                continue
+
+            needs_flag = False
+            for item in dec_data.get("considered", []):
+                for eval_item in item.get("evaluations", []):
+                    if eval_item.get("req") in stale_reqs:
+                        needs_flag = True
+                        break
+            
+            if needs_flag:
+                dec_data["status"] = "needs_review"
+                with open(p, "w", encoding="utf-8") as f:
+                    self.yaml.dump(dec_data, f)
+                updated_count += 1
+        return updated_count
+
+    def check_graph_validity(self) -> list:
+        """Scans the database layout for any unconfirmed reviews or broken links."""
+        violations = []
+        dec_dir = self.ctx_dir / "decisions"
+        if dec_dir.exists():
+            for p in dec_dir.glob("*.yaml"):
+                with open(p, "r", encoding="utf-8") as f:
+                    d = self.yaml.load(f)
+                    if d and d.get("status") == "needs_review":
+                        violations.append(f"Decision '{d.get('id')}' [{d.get('chosen').upper()}] is flagged as 'needs_review'.")
+        return violations
+
+    def mine_git_history(self, count: int = 10) -> int:
+        """Queries the local repository logs and saves structured reasoning JSON entries."""
+        import subprocess
+        import json
+        from datetime import datetime
+
+        raw_dir = self.ctx_dir / ".raw"
+        raw_dir.mkdir(parents=True, exist_ok=True)
+
+        try:
+            cmd = ["git", "log", f"-n {count}", "--pretty=format:%H||%an||%ad||%s%b", "--date=short"]
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True, encoding="utf-8")
+            log_lines = result.stdout.strip().split("\n")
+        except Exception:
+            return 0
+
+        mined_count = 0
+        keywords = ["because", "requires", "reverts", "fixes", "breaking change"]
+
+        for line in log_lines:
+            if not line or "||" not in line:
+                continue
+            parts = line.split("||")
+            if len(parts) < 4:
+                continue
+            commit_hash, author, date_str, message = parts[0], parts[1], parts[2], parts[3]
+
+            if any(kw in message.lower() for kw in keywords):
+                payload = {
+                    "source": "git_history_miner",
+                    "commit": commit_hash,
+                    "author": author,
+                    "date": date_str,
+                    "extracted_text": message,
+                    "timestamp_mined": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                }
+                output_file = raw_dir / f"git_mined_{commit_hash[:8]}.json"
+                if not output_file.exists():
+                    with open(output_file, "w", encoding="utf-8") as out:
+                        json.dump(payload, out, indent=2)
+                    mined_count += 1
+        return mined_count
+
+    def execute_llm_distillation(self, text_content: str, api_key: str, model_name: str = "gpt-4o-mini") -> str:
+        """Pipes unstructured log pools out to OpenAI schema compilation nodes."""
+        import urllib.request
+        import json
+
+        system_prompt = (
+            "You are the extraction engine for konman (Context Manager).\n"
+            "Your job is to read raw development logs/transcripts and distill architectural context.\n"
+            "Format output strictly as raw JSON text matching this syntax structural layout without markdown formatting backticks:\n"
+            "{\n"
+            "  \"requirements\": [{ \"id\": \"R-XXX\", \"statement\": \"...\", \"kind\": \"hard|preference\", \"why\": \"...\" }],\n"
+            "  \"decisions\": [{ \"id\": \"D-XXX\", \"chosen\": \"...\", \"mode\": \"compared\", \"reason\": \"...\" }]\n"
+            "}"
+        )
+
+        url = "https://openai.com"
+        headers = {"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"}
+        data = {
+            "model": model_name,
+            "response_format": {"type": "json_object"},
+            "messages": [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": text_content}
+            ]
+        }
+
+        try:
+            req = urllib.request.Request(url, data=json.dumps(data).encode("utf-8"), headers=headers, method="POST")
+            with urllib.request.urlopen(req, timeout=30) as response:
+                res_data = json.loads(response.read().decode("utf-8"))
+                return res_data["choices"]["message"]["content"]
+        except Exception as e:
+            return f"{{\"error\": \"LLM Pipeline disconnect: {str(e)}\"}}"
+
+    def compile_agents_md(self):
+        """Compiles active definitions directly into a universal markdown overview proxy file."""
+        agents_path = self.base_dir / "AGENTS.md"
+        req_summary = []
+        req_dir = self.ctx_dir / "requirements"
+        
+        if req_dir.exists():
+            for p in req_dir.glob("*.yaml"):
+                with open(p, "r", encoding="utf-8") as f:
+                    r = self.yaml.load(f)
+                    if r and r.get("status") == "active":
+                        req_summary.append(f"- **{r.get('id')}** [{r.get('kind').upper()}]: {r.get('statement')}")
+
+        content = (
+            "# 🤖 PROJECT CONTEXT DIRECTORY\n\n"
+            "This file is auto-generated by **`konman`**. Do not edit directly.\n\n"
+            "## 📌 Active System Architectural Requirements\n"
+            + ("\n".join(req_summary) if req_summary else "No active architecture rules recorded.")
+            + "\n\n## 🔍 Read Manifest Maps\n"
+            "Refer to the local repository schema files stored within `.context/` paths.\n"
+        )
+        with open(agents_path, "w", encoding="utf-8") as f:
+            f.write(content)

konman/models.py

@@ -0,0 +1,45 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional, Literal, Dict, Any, Union
+
+class Requirement(BaseModel):
+    id: str
+    statement: str
+    kind: Literal["hard", "preference"]
+    priority: Optional[str] = "medium"
+    source: Dict[str, str] = Field(default_factory=lambda: {"who": "human", "when": ""})
+    why: Optional[str] = None
+    derives_from: Optional[str] = None
+    status: Literal["active", "superseded", "disproven"] = "active"
+    added: Optional[Literal["standard", "retroactive"]] = "standard"
+
+class Property(BaseModel):
+    key: str
+    value: Any
+    evidence: Literal["measured", "documented", "claimed"]
+
+class Evaluation(BaseModel):
+    req: str
+    result: Literal["pass", "fail", "partial"]
+    via: str
+
+class ConsideredObject(BaseModel):
+    object: str
+    properties: List[Property] = Field(default_factory=list)
+    evaluations: List[Evaluation] = Field(default_factory=list)
+    verdict: Literal["selected", "rejected", "proposed"]
+
+class Decision(BaseModel):
+    id: str
+    chosen: str
+    mode: Literal["compared", "default", "forced", "taste"] = "compared"
+    decided: Dict[str, str] = Field(default_factory=lambda: {"who": "unknown", "when": ""})
+    considered: List[ConsideredObject] = Field(default_factory=list)
+    tradeoff: Optional[str] = None
+    reason: Optional[str] = None
+    status: Literal["active", "needs_review", "superseded"] = "active"
+
+class BoundaryRule(BaseModel):
+    path: str
+    constrains: List[str] = Field(default_factory=list)
+    rule: str = "no_edit_without_approval"
+    why: str

konman-1.0.0.dist-info/METADATA

@@ -0,0 +1,189 @@
+Metadata-Version: 2.4
+Name: konman
+Version: 1.0.0
+Summary: 🧠 konman: An automated, first-principles, LLM-agnostic codebase context engine.
+Author-email: Your Name <your.email@example.com>
+Project-URL: Homepage, https://github.com
+Project-URL: Issues, https://github.com/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: ruamel.yaml>=0.17.0
+
+# 🧠 konman (Context Manager) v1.0.0
+
+An automated, first-principles, LLM-agnostic codebase context engine. **konman** decouples developer context from ephemeral chat sessions and anchors it directly inside your codebase as version-controlled data. 
+
+---
+
+## 🎯 Core Philosophy
+
+Standard AI-driven development tools lock your project's history inside localized chat interfaces or vendor ecosystems. When your API tokens expire or you switch models, the new assistant lacks the complete picture, often modifying code it shouldn't touch or re-proposing rejected options.
+
+**konman** solves this by breaking context down into 6 fundamental dimensions:
+1. **Who**: The actor (Human or specific LLM) making the assertion.
+2. **What**: The changes made (Code modifications, symbols, diffs).
+3. **Where**: The scope of the adjustment (File paths, dependency graphs).
+4. **When**: The timeline anchor (Git commit history, session timestamps).
+5. **How**: The mechanism used (Build configs, testing assertions).
+6. **Why**: The human intent, constraints, and evaluated tradeoffs.
+
+While *What, Where, When,* and *How* can easily be recovered by indexing raw code, the **Why** is completely lost once a session vanishes. **konman** dynamically captures the "Why" at the moment it is generated, standardizing it into an evaluation matrix:
+
+\[\text{Object } (O) \xrightarrow{\text{satisfies}} \text{Requirement } (R) \text{ due to its verified Property } (P)\]
+
+---
+
+## 🚀 Quickstart & Global Installation
+
+### 1. Assemble the Package Dependencies
+Ensure you have Python 3.10+ installed. Clone your workspace and install **konman** globally in editable mode using `pip`:
+
+```bash
+cd conman_tool
+pip install -e .
+```
+
+Verify your global environment configuration setup by triggering the structured help display:
+```bash
+konman --help
+```
+
+### 2. Scaffold a Codebase Repository
+Navigate into your target software application codebase folder (e.g., `playce-api`) and initialize the context filesystem:
+```bash
+cd /path/to/playce-api
+konman init
+```
+This deploys the underlying `.context/` data graph infrastructure:
+* `requirements/`: `.yaml` files detailing hard structural limitations and developer preferences.
+* `decisions/`: Architectural tradeoffs, chosen technologies, and rejected alternative options.
+* `boundaries.yaml`: Protected codebase paths mapped to explicit verification criteria.
+* `.raw/`: Gitignored temporary buffer cache where streaming logs are collected prior to model extraction.
+
+---
+
+## 🔌 Multi-Tool Setup & Integration Manual
+
+**konman** is built to sit between you and your developer assistants. Instead of modifying tool core logic, running `konman setup [tool-name]` drops target-specific metadata adapters into your project directory. Every adapter explicitly directs its assistant to look up instructions from a centralized, auto-compiled index file named `AGENTS.md`.
+
+### 1. Antigravity Setup
+Antigravity utilizes dynamic lifecycle event hooks and dynamic background JSON-RPC configurations.
+* **Setup Command**: 
+  ```bash
+  konman setup antigravity
+  ```
+* **What it configures**: 
+  Appends background server hooks directly to your system profile data (`~/.gemini/config/mcp_config.json`) and drops an event configuration module down at `.agents/hooks.json`.
+* **Workflow**: 
+  Every time you submit a prompt or close a chat panel shell inside Antigravity, the tool pipes background conversation logs straight to `.context/.raw/` silently using an insulated, fail-open background channel.
+
+### 2. VS Code Copilot Setup
+VS Code Copilot blocks background lifecycle execution commands but natively queries structural instruction parameters.
+* **Setup Command**: 
+  ```bash
+  konman setup vsc-copilot
+  ```
+* **What it configures**: 
+  Creates a workspace routing directory at `.github/copilot-instructions.md`.
+* **Workflow**: 
+  Because Copilot restricts third-party process eavesdropping, use the continuous window cache scraping utility to pull past conversation prompts from your system log directory:
+  ```bash
+  konman tail
+  ```
+
+### 3. Cursor Setup
+Cursor allows developers to enforce custom system guidelines over matching codebase directory modules.
+* **Setup Command**: 
+  ```bash
+  konman setup cursor
+  ```
+* **What it configures**: 
+  Generates a system override rule file at `.cursor/rules/konman-context.mdc`.
+* **Workflow**: 
+  The file is pre-configured with rules (`alwaysApply: true`, `globs: "*"`) that force the Cursor model to crawl `AGENTS.md` boundaries before proposing code modifications.
+
+### 4. Claude Code Setup
+Claude Code looks up structural constraints from plain markdown files situated in the repository root path.
+* **Setup Command**: 
+  ```bash
+  konman setup claude-code
+  ```
+* **What it configures**: 
+  Creates a standard `CLAUDE.md` control file.
+* **Workflow**: 
+  It defines absolute constraints, instructing the Claude Code terminal runner to scan your active requirements schema before running build scripts or code rewrites.
+
+### 5. Codex Setup
+Codex tracks state parameters across isolated session tracking layouts.
+* **Setup Command**: 
+  ```bash
+  konman setup codex
+  ```
+* **What it configures**: 
+  Deploys a standard workspace tracker layout at `.codex/`.
+
+### 6. Kiro Setup
+Kiro relies on system steering inputs to orchestrate background model automation scripts.
+* **Setup Command**: 
+  ```bash
+  konman setup kiro
+  ```
+* **What it configures**: 
+  Deploys explicit semantic steering files to `.kiro/steering/context_steering.md`.
+
+---
+
+## 🛠️ Operational Command Reference
+
+### 🎯 Core Workspace Management Commands
+
+| Command | Syntax / Usage | Operational Description |
+| :--- | :--- | :--- |
+| **`init`** | `konman init` | Scaffolds the standard `.context/` data graph layout inside a code repository. |
+| **`setup`** | `konman setup [tool-choice]` | Deploys targeted workspace adapters (`antigravity`, `claude-code`, `codex`, `vsc-copilot`, `cursor`, `kiro`). |
+| **`sync`** | `konman sync` | Traces dependencies, processes staleness propagation rules, and regenerates `AGENTS.md`. |
+| **`state`** | `konman state` | Renders a terminal visualization tree detailing active requirements, recent choices, and untracked queues. |
+| **`record`** | `konman record -t [type] -i [id]` | Launches an interactive console wizard to manually log a new `requirement`, `decision`, or `boundary`. |
+| **`resolve`** | `konman resolve [id]` | Reconciles stale nodes flagged with `needs_review`, updating trade-off justifications and healing the graph. |
+| **`check`** | `konman check` | Audits the graph database. Returns error code `1` if any node requires review. Used as a pre-commit block. |
+| **`config`** | `konman config -k [key]` | Securely locks your developer LLM platform API key credentials to `~/.config/konman/config.json`. |
+| **`setup-hooks`** | `konman setup-hooks` | Injects an automated verification shell script loop directly into your local `.git/hooks/pre-commit` workflow. |
+| **`disable-hooks`** | `konman disable-hooks` | Safely tears down and decouples the konman validation script from your local Git pre-commit lifecycles. |
+
+### 🔌 Context Extraction & Lifecycle Pipelines
+
+| Command | Syntax / Usage | Operational Description |
+| :--- | :--- | :--- |
+| **`tail`** | `konman tail` | Scrapes deeply nested Windows VS Code cache paths to pull your active Copilot transcript history. |
+| **`mine`** | `konman mine -c [count]` | Parses your local Git commit history trail to extract structural reasoning clues from message text blocks. |
+| **`extract`** | `konman extract` | Pipes collected logs from `.context/.raw/` into your LLM to automatically synthesize fresh `.yaml` nodes. |
+| **`handoff`** | `konman handoff [from] [to]` | Packages context boundaries for a new model window and updates active adapters to point to the new tool. |
+
+---
+
+## 🔒 Enforcement Guardrails & Git Lifecycles
+
+To guarantee that stale information or unconfirmed context models are caught before code is pushed to a remote server, embed **konman** directly into your repository's local Git workflow gates.
+
+### Activating the Protection Guardrail:
+Run this command inside your target codebase application directory:
+```bash
+konman setup-hooks
+```
+This creates an automated shell script at `.git/hooks/pre-commit` that intercepts every `git commit` attempt to execute `konman check`. If an upstream requirement has been `superseded` or changed, all down-tree decisions automatically lock into a `needs_review` phase, and **konman blocks the commit sequence**. Run `konman resolve [id]` to input your updated tradeoffs and unblock the pipeline instantly.
+
+### Opting Out / Disabling the Guardrail:
+If you need to lift the validation gates for temporary testing cycles, bypass the pre-commit checks, or remove **konman** from your automated lifecycle track, execute the decoupling unlinker:
+```bash
+konman disable-hooks
+```
+This safely inspects the pre-commit script file and destroys the execution hooks without risking damage to third-party tools or modifications to your untracked source directories.

konman-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+konman/__init__.py,sha256=NuioNGPPi8nJca__wCTcFO5xV8mdHMl5LH0QWzwO5rM,74
+konman/cli.py,sha256=uPtOQZRc5bv_G0sRqzo1mjGEr_GPhjVNArK_1VHZFW8,24777
+konman/config.py,sha256=PpVB3ViYo1NlnFcw7Ai3x-U5YYAEVJ4eNfegGh4gs_c,6181
+konman/engine.py,sha256=bVQksanW8ihPpJaKWjAViS2LF8M-_q051FMT1mlW9uQ,7836
+konman/models.py,sha256=TsL5_z5eQ3hflH-_iUTYGcS7yyRNOnaIpMK49oSeUpc,1619
+konman-1.0.0.dist-info/METADATA,sha256=loJBx13H9ulb6XUNcxuLpfTtj0FvsW6FGzwYIHGF-So,10079
+konman-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+konman-1.0.0.dist-info/entry_points.txt,sha256=ESLYDNrTLzVyLNV7S-_akPtQoLjoOWeSDEIO_ry8MUA,43
+konman-1.0.0.dist-info/top_level.txt,sha256=W3wm7QHmiE--grPojtlr7mphNMqWEYx98C0rTO8EJ4Q,7
+konman-1.0.0.dist-info/RECORD,,

konman-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

konman-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+konman = konman.cli:main

konman-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+konman