devmind.py

"""DevMind CLI -- setup, seed, status, and brief commands."""

import argparse
import asyncio
import sys


def cmd_setup(args):
    """Create the SurrealDB schema."""
    from db.client import DevMindDB

    async def _run():
        db = DevMindDB()
        await db.connect()
        try:
            await db.setup_schema()
        finally:
            await db.disconnect()

    asyncio.run(_run())
    print("[DevMind] schema created")


def cmd_seed(args):
    """Seed the database with demo data."""
    project = args.project or "auth-service"

    async def _run():
        from seed.seed_data import run_seed
        await run_seed(project)

    asyncio.run(_run())


def cmd_status(args):
    """Query and display node counts from SurrealDB."""
    from db.client import DevMindDB, extract_count

    async def _run():
        db = DevMindDB()
        await db.connect()
        try:
            tables = {
                "errors": "error",
                "fixes": "fix",
                "decisions": "decision",
                "patterns": "pattern",
                "files": "file",
            }

            counts = {}
            for label, table in tables.items():
                result = await db.query(
                    f"SELECT count() FROM {table} WHERE project = $p GROUP ALL;",
                    {"p": args.project},
                )
                counts[label] = extract_count(result)

            lm_result = await db.query(
                "SELECT count() FROM error WHERE project = $p AND landmine = true GROUP ALL;",
                {"p": args.project},
            )
            landmine_count = extract_count(lm_result)

            print(f"\n  DevMind Status -- {args.project}")
            print("  " + "-" * 35)
            print(f"  errors:    {counts.get('errors', 0):>4}  (landmines: {landmine_count})")
            print(f"  fixes:     {counts.get('fixes', 0):>4}")
            print(f"  decisions: {counts.get('decisions', 0):>4}")
            print(f"  patterns:  {counts.get('patterns', 0):>4}")
            print(f"  files:     {counts.get('files', 0):>4}")
            print()

        finally:
            await db.disconnect()

    asyncio.run(_run())


def cmd_brief(args):
    """Generate and print the project brief."""
    from brief.generator import generate_brief

    result = asyncio.run(generate_brief(args.project))
    print(result)


def main():
    parser = argparse.ArgumentParser(
        prog="devmind",
        description="DevMind -- graph-native project memory for AI dev teams",
    )
    subparsers = parser.add_subparsers(dest="command", help="Available commands")

    # setup
    sp_setup = subparsers.add_parser("setup", help="Create SurrealDB schema")
    sp_setup.set_defaults(func=cmd_setup)

    # seed
    sp_seed = subparsers.add_parser("seed", help="Seed database with demo data")
    sp_seed.add_argument("--project", default=None, help="Project name (default: auth-service)")
    sp_seed.set_defaults(func=cmd_seed)

    # status
    sp_status = subparsers.add_parser("status", help="Show node counts")
    sp_status.add_argument("--project", required=True, help="Project name")
    sp_status.set_defaults(func=cmd_status)

    # brief
    sp_brief = subparsers.add_parser("brief", help="Generate project brief")
    sp_brief.add_argument("--project", required=True, help="Project name")
    sp_brief.set_defaults(func=cmd_brief)

    args = parser.parse_args()

    if not args.command:
        parser.print_help()
        sys.exit(1)

    args.func(args)


if __name__ == "__main__":
    main()