dotai-cli 0.1.1__py3-none-any.whl

dotai/__init__.py

@@ -0,0 +1,3 @@
+"""dotai — Universal AI context for any coding agent."""
+
+__version__ = "0.1.1"

dotai/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running dotai as: python -m dotai"""
+
+from .cli import app
+
+app()

dotai/cli/__init__.py

@@ -0,0 +1,148 @@
+"""dotai CLI — manage ~/.ai/ knowledge, roles, skills, and agent sync."""
+
+import shutil
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from .. import __version__
+
+
+def _version_callback(value: bool):
+    if value:
+        print(f"dotai {__version__}")
+        raise typer.Exit()
+
+
+app = typer.Typer(help="Universal AI context for any coding agent.", no_args_is_help=True)
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(False, "--version", "-V", callback=_version_callback, is_eager=True, help="Show version and exit"),
+):
+    pass
+console = Console()
+
+SEED_DIR = Path(__file__).parent.parent / "seed"
+
+
+@app.command()
+def init(
+    project: Optional[str] = typer.Argument(None, help="Project path to initialize (omit for global ~/.ai/)"),
+    force: bool = typer.Option(False, "--force", "-f", help="Re-seed missing/updated roles and skills (overwrites seeds, keeps custom files)"),
+):
+    """Initialize ~/.ai/ with seed roles and skills, or add .ai/ to a project.
+
+    Use --force to re-seed after upgrading dotai (overwrites seed files, keeps your custom files).
+    """
+    from ..store import load_config, save_config
+    from ..models import ProjectConfig
+
+    if project:
+        # Project init
+        project_path = Path(project).expanduser().resolve()
+        if not project_path.exists():
+            console.print(f"[red]Path does not exist: {project_path}[/red]")
+            raise typer.Exit(1)
+
+        ai_dir = project_path / ".ai"
+        ai_dir.mkdir(exist_ok=True)
+        (ai_dir / "rules").mkdir(exist_ok=True)
+        (ai_dir / "roles").mkdir(exist_ok=True)
+        (ai_dir / "skills").mkdir(exist_ok=True)
+        (ai_dir / "tools").mkdir(exist_ok=True)
+
+        # Create starter files
+        if not (ai_dir / "rules.md").exists():
+            (ai_dir / "rules.md").write_text(
+                "# Project Rules\n\nProject-specific conventions and guidelines.\n"
+            )
+        # Register in config
+        config = load_config()
+        config.add_project(ProjectConfig(
+            name=project_path.name,
+            path=project_path,
+        ))
+        save_config(config)
+
+        console.print(f"[green]Initialized .ai/ in {project_path}[/green]")
+        console.print(f"  Created: rules.md, roles/, skills/, tools/")
+
+        # Auto-sync agent config files into the project
+        from ..sync import sync_project
+        written = sync_project(project_path, config, project_path.name)
+        for f in written:
+            console.print(f"  [green]Synced[/green] {f}")
+    else:
+        # Global init
+        ai_dir = Path.home() / ".ai"
+        ai_dir.mkdir(exist_ok=True)
+
+        # Copy seed roles
+        roles_dir = ai_dir / "roles"
+        roles_dir.mkdir(exist_ok=True)
+        seed_roles = SEED_DIR / "roles"
+        if seed_roles.exists():
+            copied = 0
+            for role_file in seed_roles.glob("*.md"):
+                dest = roles_dir / role_file.name
+                if force or not dest.exists():
+                    shutil.copy2(role_file, dest)
+                    copied += 1
+            if copied:
+                verb = "Updated" if force else "Seeded"
+                console.print(f"  {verb} {copied} roles")
+
+        # Copy seed skills (files and folders)
+        skills_dir = ai_dir / "skills"
+        skills_dir.mkdir(exist_ok=True)
+        seed_skills = SEED_DIR / "skills"
+        if seed_skills.exists():
+            copied = 0
+            # Single-file skills
+            for skill_file in seed_skills.glob("*.md"):
+                dest = skills_dir / skill_file.name
+                if force or not dest.exists():
+                    shutil.copy2(skill_file, dest)
+                    copied += 1
+            # Folder-based skills
+            for item in seed_skills.iterdir():
+                if item.is_dir() and (item / "main.md").exists():
+                    dest = skills_dir / item.name
+                    if force or not dest.exists():
+                        if dest.exists():
+                            shutil.rmtree(dest)
+                        shutil.copytree(item, dest)
+                        copied += 1
+            if copied:
+                verb = "Updated" if force else "Seeded"
+                console.print(f"  {verb} {copied} skills")
+
+        # Create rules and tools dirs
+        (ai_dir / "rules").mkdir(exist_ok=True)
+        (ai_dir / "tools").mkdir(exist_ok=True)
+
+        # Create starter files
+        if not (ai_dir / "rules.md").exists():
+            (ai_dir / "rules.md").write_text(
+                "# Global Rules\n\nUniversal AI coding rules across all projects.\n\n"
+                "## Code Quality\n\n- Write clear, readable code\n- Handle errors explicitly\n"
+                "- Prefer simple solutions over clever ones\n"
+            )
+        console.print(f"[green]Initialized ~/.ai/[/green]")
+        console.print(f"  {ai_dir}/rules.md")
+        console.print(f"  {ai_dir}/roles/ ({len(list(roles_dir.glob('*.md')))} roles)")
+        console.print(f"  {ai_dir}/skills/ ({len(list(skills_dir.glob('*.md')))} skills)")
+        console.print(f"  {ai_dir}/tools/")
+        console.print(f"\n[dim]Next: cd into a project and run `dotai sync` to generate agent configs.[/dim]")
+
+
+# Import submodules to register their commands with the app
+from . import roles_cmd   # noqa: E402, F401
+from . import skills_cmd  # noqa: E402, F401
+from . import rules_cmd   # noqa: E402, F401
+from . import sync_cmd    # noqa: E402, F401
+from . import watch_cmd   # noqa: E402, F401

dotai/cli/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running dotai as: python -m dotai.cli"""
+
+from . import app
+
+app()

dotai/cli/roles_cmd.py

@@ -0,0 +1,62 @@
+"""CLI commands for roles."""
+
+from typing import Optional
+
+import typer
+from rich.table import Table
+
+from . import app, console
+
+
+@app.command()
+def roles():
+    """List all available roles."""
+    from ..store import load_config
+    from ..roles import load_all_roles
+
+    config = load_config()
+    all_roles = load_all_roles(config)
+
+    if not all_roles:
+        console.print("[dim]No roles found. Run `dotai init` to seed default roles.[/dim]")
+        return
+
+    table = Table(title="Available Roles")
+    table.add_column("Name", style="bold")
+    table.add_column("Scope", style="dim")
+    table.add_column("Description")
+    table.add_column("Tags", style="dim")
+
+    for role in all_roles:
+        table.add_row(role.id, role.scope, role.description[:60], ", ".join(role.tags))
+
+    console.print(table)
+
+
+@app.command()
+def role(
+    name: str = typer.Argument(..., help="Role ID to output (e.g. qa, paranoid-reviewer, debugger)"),
+):
+    """Output a role's full prompt to stdout.
+
+    Use this to inject a persona into any agent:
+      dotai role qa | pbcopy
+      dotai role paranoid-reviewer > /tmp/role.md
+    """
+    from ..store import load_config
+    from ..roles import load_all_roles
+
+    config = load_config()
+    all_roles = load_all_roles(config)
+
+    matched = next((r for r in all_roles if r.id == name), None)
+
+    if not matched:
+        console.print(f"[red]Role '{name}' not found.[/red]")
+        console.print("Available roles:")
+        for r in all_roles:
+            console.print(f"  {r.id}: {r.description[:60]}")
+        raise typer.Exit(1)
+
+    # print() intentional — stdout for piping, no Rich markup
+    print(matched.to_prompt())

dotai/cli/rules_cmd.py

@@ -0,0 +1,202 @@
+"""CLI commands for rules."""
+
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.table import Table
+
+from . import app, console
+
+
+@app.command()
+def rules(
+    project: Optional[str] = typer.Option(None, "--project", "-p", help="Show rules resolved for a project"),
+    all: bool = typer.Option(False, "--all", "-a", help="Show all rules including disabled"),
+):
+    """List rules. Shows resolved active rules by default."""
+    from ..store import load_config
+    from ..rules import load_all_rules, resolve_rules_for_project
+
+    config = load_config()
+
+    if all:
+        rule_list = load_all_rules(config)
+    elif project:
+        rule_list = resolve_rules_for_project(config, project)
+    else:
+        rule_list = load_all_rules(config)
+
+    if not rule_list:
+        console.print("[dim]No rules found. Use `dotai learn` to add rules.[/dim]")
+        return
+
+    # Check project disabled list for display
+    disabled_ids: set[str] = set()
+    if project:
+        proj = config.get_project(project)
+        if proj:
+            disabled_ids = set(proj.disabled_rules)
+
+    title = f"Rules (project: {project})" if project else "Rules"
+    table = Table(title=title)
+    table.add_column("Name", style="bold")
+    table.add_column("Status", style="green")
+    table.add_column("Scope", style="dim")
+    table.add_column("Globs", style="cyan")
+    table.add_column("Tags", style="dim")
+    table.add_column("Description")
+
+    for rule in rule_list:
+        if rule.id in disabled_ids:
+            status = "[red]disabled (project)[/red]"
+        elif not rule.enabled:
+            status = "[red]disabled[/red]"
+        else:
+            status = "[green]on[/green]"
+        table.add_row(
+            rule.id,
+            status,
+            rule.scope,
+            ", ".join(rule.globs) if rule.globs else "",
+            ", ".join(rule.tags),
+            rule.description[:50],
+        )
+
+    console.print(table)
+
+
+@app.command()
+def toggle(
+    rule_id: str = typer.Argument(..., help="Rule ID to toggle (e.g. no-useeffect)"),
+    project: Optional[str] = typer.Option(None, "--project", "-p", help="Toggle for a specific project only"),
+    on: bool = typer.Option(False, "--on", help="Enable the rule"),
+    off: bool = typer.Option(False, "--off", help="Disable the rule"),
+):
+    """Enable or disable a rule globally or for a specific project.
+
+    Globally:  dotai toggle no-useeffect --off
+    Per project: dotai toggle no-useeffect --off -p my-legacy-app
+    """
+    from ..store import load_config
+    from ..rules import toggle_rule_global, toggle_rule_for_project
+
+    if not on and not off:
+        console.print("[red]Specify --on or --off[/red]")
+        raise typer.Exit(1)
+
+    config = load_config()
+    enabled = on  # --on → True, --off → False
+
+    if project:
+        # Disable/enable a global rule for this project only
+        ok = toggle_rule_for_project(config, project, rule_id, disabled=not enabled)
+        if ok:
+            state = "enabled" if enabled else "disabled"
+            console.print(f"[green]Rule '{rule_id}' {state} for project '{project}'[/green]")
+        else:
+            console.print(f"[red]Project '{project}' not found or rule already in that state[/red]")
+            raise typer.Exit(1)
+    else:
+        # Toggle globally in the rule's frontmatter
+        rules_dir = config.global_rules_path
+        ok = toggle_rule_global(rule_id, rules_dir, enabled)
+        if ok:
+            state = "enabled" if enabled else "disabled"
+            console.print(f"[green]Rule '{rule_id}' {state} globally[/green]")
+        else:
+            console.print(f"[red]Rule '{rule_id}' not found in {rules_dir}[/red]")
+            raise typer.Exit(1)
+
+
+@app.command()
+def learn(
+    title: str = typer.Argument(..., help="Short title for the rule or learning"),
+    from_file: Optional[str] = typer.Option(None, "--from-file", "-f", help="Import rule from a file"),
+    issue: Optional[str] = typer.Option(None, "--issue", "-i", help="What went wrong (inline mode)"),
+    correction: Optional[str] = typer.Option(None, "--correction", "-c", help="What to do instead (inline mode)"),
+    description: Optional[str] = typer.Option(None, "--description", "-d", help="One-line description"),
+    globs: Optional[str] = typer.Option(None, "--globs", "-g", help="File patterns this rule applies to (e.g. '*.tsx,*.ts')"),
+    tags: Optional[str] = typer.Option(None, "--tags", "-t", help="Comma-separated tags"),
+    project: Optional[str] = typer.Option(None, "--project", "-p", help="Project name (writes to project rules/)"),
+):
+    """Add a rule from a file or record an inline learning.
+
+    From file (creates structured rule in ~/.ai/rules/):
+      dotai learn "no-useEffect" -f react-rule.md -g "*.tsx,*.ts"
+
+    Inline learning (appends to rules.md):
+      dotai learn "title" -i "what went wrong" -c "what to do instead"
+    """
+    from ..store import load_config
+
+    if not from_file and not (issue and correction):
+        console.print("[red]Provide --from-file, or --issue and --correction[/red]")
+        raise typer.Exit(1)
+
+    config = load_config()
+
+    if from_file:
+        from ..rules import create_rule_from_file
+
+        source = Path(from_file).expanduser().resolve()
+        if not source.exists():
+            console.print(f"[red]File not found: {source}[/red]")
+            raise typer.Exit(1)
+
+        # Determine target rules directory
+        if project:
+            proj = config.get_project(project)
+            if not proj:
+                console.print(f"[red]Project '{project}' not found[/red]")
+                raise typer.Exit(1)
+            rules_dir = proj.rules_path
+        else:
+            rules_dir = config.global_rules_path
+
+        glob_list = [g.strip() for g in globs.split(",")] if globs else None
+        tag_list = [t.strip() for t in tags.split(",")] if tags else None
+
+        dest = create_rule_from_file(
+            source_path=source,
+            name=title,
+            dest_dir=rules_dir,
+            description=description,
+            globs=glob_list,
+            tags=tag_list,
+        )
+
+        console.print(f"[green]Rule created:[/green] {title}")
+        console.print(f"  [dim]{dest}[/dim]")
+
+        # Show what was detected
+        from ..rules import parse_rule_file
+        rule = parse_rule_file(dest)
+        if rule:
+            if rule.tags:
+                console.print(f"  Tags: {', '.join(rule.tags)}")
+            if rule.globs:
+                console.print(f"  Globs: {', '.join(rule.globs)}")
+            console.print(f"  Description: {rule.description}")
+    else:
+        # Inline learning — append to rules.md
+        if project:
+            proj = config.get_project(project)
+            if not proj:
+                console.print(f"[red]Project '{project}' not found[/red]")
+                raise typer.Exit(1)
+            rules_path = proj.full_ai_path / "rules.md"
+        else:
+            rules_path = config.global_ai_dir / "rules.md"
+
+        rules_path.parent.mkdir(parents=True, exist_ok=True)
+
+        entry = f"\n### {datetime.now().strftime('%Y-%m-%d')}: {title}\n"
+        entry += f"**Issue:** {issue}\n"
+        entry += f"**Correction:** {correction}\n"
+
+        with open(rules_path, "a") as f:
+            f.write(entry)
+
+        console.print(f"[green]Recorded learning:[/green] {title}")