dadaia-workspace 0.1.0__tar.gz

dadaia_workspace-0.1.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.1
+Name: dadaia-workspace
+Version: 0.1.0
+Summary: AI-native workspace management CLI with Spec Context Projects
+Author: Marco Menezes
+Author-email: marcoaurelioreislima@gmail.com
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: openpyxl (>=3.1,<4.0)
+Requires-Dist: pyyaml (>=6.0,<7.0)
+Requires-Dist: rich (>=13,<14)
+Requires-Dist: typer[all] (>=0.25)
+Description-Content-Type: text/markdown
+
+# dadaia-workspace
+
+## Guardrails do Repositorio
+
+- `bash scripts/check_no_repo_local_claude.sh`: falha se a pasta proibida `dadaia-workspace/.claude/` reaparecer no subprojeto.
+- A unica fonte versionada de rules, skills e commands do produto e `dadaia_workspace/public/`.
+- O destino de instalacao continua sendo a `.claude/` na raiz do workspace do usuario.
+
+## VPS
+
+Gerenciado a partir de `srv1608865.hstgr.cloud` — setup 2026-05-08.
+

dadaia_workspace-0.1.0/README.md

@@ -0,0 +1,11 @@
+# dadaia-workspace
+
+## Guardrails do Repositorio
+
+- `bash scripts/check_no_repo_local_claude.sh`: falha se a pasta proibida `dadaia-workspace/.claude/` reaparecer no subprojeto.
+- A unica fonte versionada de rules, skills e commands do produto e `dadaia_workspace/public/`.
+- O destino de instalacao continua sendo a `.claude/` na raiz do workspace do usuario.
+
+## VPS
+
+Gerenciado a partir de `srv1608865.hstgr.cloud` — setup 2026-05-08.

dadaia_workspace-0.1.0/dadaia_workspace/cli/commands/academy.py

@@ -0,0 +1,113 @@
+"""dadaia academy subcommands."""
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from dadaia_workspace import container
+from dadaia_workspace.core.exceptions import ContextAlreadyExistsError, ContextNotFoundError
+from dadaia_workspace.features.academy.service import AcademyService
+
+app = typer.Typer(help="Manage Academy courses.")
+console = Console()
+err_console = Console(stderr=True)
+
+
+def _resolve_workspace() -> Path:
+    cwd = Path.cwd()
+    for parent in [cwd, *cwd.parents]:
+        if (parent / ".dadaia").exists():
+            return parent
+    return cwd
+
+
+def _academy_service() -> AcademyService:
+    workspace_root = _resolve_workspace()
+    return container.build_academy_service(workspace_root)
+
+
+@app.command()
+def modules() -> None:
+    """List available Academy modules from the built-in knowledge base."""
+    svc = _academy_service()
+    mods = svc.list_modules()
+    if not mods:
+        console.print("[dim]No modules found.[/dim]")
+        return
+    for number, name in mods:
+        console.print(f"  {number:2d}  {name}")
+
+
+@app.command(name="list")
+def list_all() -> None:
+    """List all courses in this workspace."""
+    svc = _academy_service()
+    courses = svc.list_all()
+    if not courses:
+        console.print("[dim]No courses found. Use 'dadaia academy create' to start one.[/dim]")
+        return
+
+    table = Table(title="Academy Courses")
+    table.add_column("Slug", style="bold")
+    table.add_column("Name")
+    table.add_column("Module")
+    table.add_column("Created")
+
+    for course in courses:
+        table.add_row(
+            course.slug,
+            course.name,
+            f"{course.module_number} — {course.module_name}",
+            course.created_at[:10],
+        )
+    console.print(table)
+
+
+@app.command()
+def create(
+    name: str = typer.Argument(..., help="Course name"),
+    module: int = typer.Option(..., "--module", "-m", help="Module number"),
+) -> None:
+    """Create a new course from a knowledge base module."""
+    try:
+        course = _academy_service().create(name, module)
+        console.print(
+            f"[green]✓[/green] Course '[bold]{course.slug}[/bold]' created "
+            f"from module {course.module_number} ({course.module_name})"
+        )
+        console.print(f"  Course dir: {course.course_dir}")
+    except (ContextAlreadyExistsError, ContextNotFoundError) as e:
+        err_console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1) from None
+
+
+@app.command()
+def update(
+    slug: str = typer.Argument(..., help="Course slug"),
+    module: int = typer.Option(..., "--module", "-m", help="New module number"),
+) -> None:
+    """Update an existing course to use a different module."""
+    try:
+        course = _academy_service().update(slug, module)
+        console.print(
+            f"[green]✓[/green] Course '[bold]{course.slug}[/bold]' updated "
+            f"to module {course.module_number} ({course.module_name})"
+        )
+    except ContextNotFoundError as e:
+        err_console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1) from None
+
+
+@app.command()
+def delete(
+    slug: str = typer.Argument(..., help="Course slug to delete"),
+) -> None:
+    """Delete a course and its working directory."""
+    try:
+        _academy_service().delete(slug)
+        console.print(f"[green]✓[/green] Course '[bold]{slug}[/bold]' deleted")
+    except ContextNotFoundError as e:
+        err_console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1) from None

dadaia_workspace-0.1.0/dadaia_workspace/cli/commands/context.py

@@ -0,0 +1,222 @@
+"""dadaia context subcommands."""
+
+import json
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from dadaia_workspace import container
+from dadaia_workspace.core.exceptions import (
+    ContextAlreadyExistsError,
+    ContextNotFoundError,
+    ContextStateError,
+    RepoCatalogError,
+    WorkspaceNotInitializedError,
+)
+from dadaia_workspace.core.models.spec_context import ContextState, SpecContextProject
+from dadaia_workspace.features.spec_context.service import SpecContextService
+
+app = typer.Typer(help="Manage Spec Context Projects.")
+console = Console()
+err_console = Console(stderr=True)
+
+
+def _resolve_workspace() -> Path:
+    cwd = Path.cwd()
+    for parent in [cwd, *cwd.parents]:
+        if (parent / ".dadaia").exists():
+            return parent
+    return cwd
+
+
+def _ctx_service() -> SpecContextService:
+    try:
+        return container.build_spec_context_service(_resolve_workspace())
+    except WorkspaceNotInitializedError:
+        err_console.print(
+            "[red]Error:[/red] Workspace not initialized. Run [bold]dadaia init[/bold] first."
+        )
+        raise typer.Exit(1) from None
+
+
+def _ctx_to_dict(ctx: SpecContextProject) -> dict:  # type: ignore[type-arg]
+    return {
+        "name": ctx.name,
+        "state": ctx.state.value,
+        "repo_slug": ctx.repo_slug,
+        "repo_url": ctx.repo_url,
+        "is_primary": ctx.is_primary,
+        "created_at": ctx.created_at,
+        "activated_at": ctx.activated_at,
+        "current_branch": ctx.current_branch,
+    }
+
+
+@app.command()
+def create(
+    name: str = typer.Argument(..., help="Context name"),
+    repo: str = typer.Option(..., "--repo", help="Repo slug (directory name under repos/)"),
+) -> None:
+    """Create a new Spec Context Project in state 'inativo'."""
+    workspace_root = _resolve_workspace()
+    # Look up repo_url from whitelist; fall back gracefully if catalog unavailable
+    repo_url = ""
+    try:
+        repos_svc = container.build_repos_service()
+        rows = repos_svc.list_known(workspace_root)
+        for row in rows:
+            if row.get("Repo Name") == repo:
+                repo_url = row.get("Repo URL", "")
+                break
+    except (RepoCatalogError, Exception):
+        pass
+
+    try:
+        ctx = _ctx_service().create(name, repo, repo_url)
+        console.print(
+            f"[green]✓[/green] Context '[bold]{ctx.name}[/bold]' created "
+            f"(repo: {ctx.repo_slug}, state: {ctx.state})"
+        )
+    except (ContextAlreadyExistsError, ContextNotFoundError) as e:
+        err_console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1) from None
+
+
+@app.command(name="list")
+def list_all() -> None:
+    """List all Spec Context Projects."""
+    contexts = _ctx_service().list_all()
+    if not contexts:
+        console.print("[dim]No contexts found. Use 'dadaia context create' to create one.[/dim]")
+        return
+
+    table = Table(title="Spec Context Projects")
+    table.add_column("Name", style="bold")
+    table.add_column("State")
+    table.add_column("Primary")
+    table.add_column("Repo")
+
+    state_style = {
+        ContextState.ATIVO: "[green]ativo[/green]",
+        ContextState.INATIVO: "[dim]inativo[/dim]",
+    }
+
+    for ctx in contexts:
+        table.add_row(
+            ctx.name,
+            state_style.get(ctx.state, ctx.state.value),
+            "[bold yellow]✓[/bold yellow]" if ctx.is_primary else "",
+            ctx.repo_slug,
+        )
+    console.print(table)
+
+
+@app.command()
+def show(
+    name: str | None = typer.Argument(None, help="Context name"),
+    json_output: bool = typer.Option(False, "--json", help="Output stable JSON contract"),
+) -> None:
+    """Show details of a context."""
+    svc = _ctx_service()
+    if name is None:
+        # Show primary context
+        all_ctxs = svc.list_all()
+        ctx = next((c for c in all_ctxs if c.is_primary), None)
+    else:
+        try:
+            ctx = svc.show(name)
+        except ContextNotFoundError as e:
+            err_console.print(f"[red]Error:[/red] {e}")
+            raise typer.Exit(1) from None
+
+    if json_output:
+        if ctx is None:
+            print(json.dumps({"context": None}, indent=2))
+        else:
+            print(json.dumps(_ctx_to_dict(ctx), indent=2))
+        return
+
+    if ctx is None:
+        msg = f"Context '{name}' not found." if name else "No primary context."
+        console.print(f"[dim]{msg}[/dim]")
+        return
+
+    console.print(f"[bold]Name:[/bold]       {ctx.name}")
+    console.print(f"[bold]State:[/bold]      {ctx.state.value}")
+    console.print(f"[bold]Primary:[/bold]    {ctx.is_primary}")
+    console.print(f"[bold]Repo:[/bold]       {ctx.repo_slug}")
+    console.print(f"[bold]Repo URL:[/bold]   {ctx.repo_url or '—'}")
+    console.print(f"[bold]Created:[/bold]    {ctx.created_at}")
+    console.print(f"[bold]Activated:[/bold]  {ctx.activated_at or '—'}")
+
+
+@app.command()
+def activate(name: str = typer.Argument(..., help="Context name to activate")) -> None:
+    """Activate a context (clone repo if absent; auto-promote if no primary)."""
+    try:
+        ws = _resolve_workspace()
+        ctx = container.build_spec_context_service(ws).activate(name)
+        primary_note = " [bold yellow](primary)[/bold yellow]" if ctx.is_primary else ""
+        console.print(
+            f"[green]✓[/green] Context '[bold]{ctx.name}[/bold]' is now active{primary_note}"
+        )
+        if ctx.is_primary:
+            container.build_public_service().install(ws, target="opencode", force=True)
+    except (ContextNotFoundError, ContextStateError) as e:
+        err_console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1) from None
+
+
+@app.command()
+def deactivate(name: str = typer.Argument(..., help="Context name to deactivate")) -> None:
+    """Deactivate a context (git sync + remove repo from disk)."""
+    try:
+        ctx = _ctx_service().deactivate(name)
+        console.print(f"[green]✓[/green] Context '[bold]{ctx.name}[/bold]' deactivated")
+    except (ContextNotFoundError, ContextStateError) as e:
+        err_console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1) from None
+
+
+@app.command()
+def promote(name: str = typer.Argument(..., help="Context name to promote as primary")) -> None:
+    """Promote an active context as the workspace primary."""
+    try:
+        ws = _resolve_workspace()
+        ctx = container.build_spec_context_service(ws).promote(name)
+        console.print(f"[green]✓[/green] Context '[bold]{ctx.name}[/bold]' is now primary")
+        container.build_public_service().install(ws, target="opencode", force=True)
+    except (ContextNotFoundError, ContextStateError) as e:
+        err_console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1) from None
+
+
+@app.command()
+def delete(name: str = typer.Argument(..., help="Context name to delete")) -> None:
+    """Delete a context. Context must be inactive."""
+    try:
+        _ctx_service().delete(name)
+        console.print(f"[green]✓[/green] Context '[bold]{name}[/bold]' deleted")
+    except (ContextNotFoundError, ContextStateError) as e:
+        err_console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1) from None
+
+
+@app.command()
+def use(name: str = typer.Argument(..., help="Context name to isolate this session to")) -> None:
+    """Isolate this shell session to a specific context without changing global state.
+
+    Run: eval $(dadaia context use <name>)
+
+    Sets DADAIA_CONTEXT for the current shell only. Does NOT modify spec_contexts.json
+    or primary_context.json.
+    """
+    all_ctxs = _ctx_service().list_all()
+    ctx = next((c for c in all_ctxs if c.name == name), None)
+    if ctx is None:
+        available = ", ".join(c.name for c in all_ctxs) or "none"
+        err_console.print(f"[red]Error:[/red] Context '{name}' not found. Available: {available}")
+        raise typer.Exit(1) from None
+    print(f"export DADAIA_CONTEXT={name}")

dadaia_workspace-0.1.0/dadaia_workspace/cli/commands/doctor.py

@@ -0,0 +1,53 @@
+"""CLI command: dadaia doctor [--fix]."""
+
+from pathlib import Path
+
+import typer
+
+from dadaia_workspace import container
+from dadaia_workspace.core.exceptions import WorkspaceNotInitializedError
+
+app = typer.Typer(help="Diagnose and repair workspace state.")
+
+
+def _resolve_workspace() -> Path:
+    cwd = Path.cwd()
+    for parent in [cwd, *cwd.parents]:
+        if (parent / ".dadaia").exists():
+            return parent
+    return cwd
+
+
+err_console = typer.echo
+
+
+@app.callback(invoke_without_command=True)
+def doctor(
+    fix: bool = typer.Option(False, "--fix", help="Apply automatic repairs."),
+) -> None:
+    """Diagnose workspace state invariants and optionally repair them."""
+    workspace_root = _resolve_workspace()
+    try:
+        dr = container.build_doctor_service(workspace_root)
+    except WorkspaceNotInitializedError:
+        typer.echo("Error: Workspace not initialized. Run 'dadaia init' first.", err=True)
+        raise typer.Exit(1) from None
+
+    issues = dr.check()
+
+    if not issues:
+        typer.echo("All invariants OK — workspace is healthy.")
+        return
+
+    typer.echo(f"Found {len(issues)} issue(s):")
+    for issue in issues:
+        fixable = "[fixable]" if issue.fixable else "[manual]"
+        typer.echo(f"  {issue.code} {fixable} — {issue.description}")
+
+    if fix:
+        actions = dr.fix()
+        typer.echo(f"\nApplied {len(actions)} repair(s):")
+        for action in actions:
+            typer.echo(f"  - {action}")
+    else:
+        typer.echo("\nRun 'dadaia doctor --fix' to apply automatic repairs.")

dadaia_workspace-0.1.0/dadaia_workspace/cli/commands/export.py

@@ -0,0 +1,67 @@
+"""dadaia export command."""
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from dadaia_workspace import container
+from dadaia_workspace.core.exceptions import DadaiaError
+from dadaia_workspace.core.models.export import ExportOptions
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+def _resolve_workspace() -> Path:
+    cwd = Path.cwd()
+    for parent in [cwd, *cwd.parents]:
+        if (parent / ".dadaia").exists():
+            return parent
+    return cwd
+
+
+def export(
+    output: Annotated[
+        Path | None,
+        typer.Option("--output", "-o", help="Output directory (default: .dadaia/dist/)."),
+    ] = None,
+    include_reports: Annotated[
+        bool,
+        typer.Option("--include-reports", help="Include .dadaia/reports/ in the archive."),
+    ] = False,
+    exclude_mnt: Annotated[
+        bool,
+        typer.Option("--exclude-mnt", help="Exclude mnt/ container volumes from the archive."),
+    ] = False,
+    list_only: Annotated[
+        bool,
+        typer.Option("--list", help="Dry-run: print manifest JSON without creating the archive."),
+    ] = False,
+) -> None:
+    """Export workspace state to a portable .tar.gz archive.
+
+    The archive includes all durable state (.dadaia/states, academy, scripts,
+    configs, .claude rules) needed to restore the workspace on a new VPS.
+    Secrets (*.env), caches (.venv, .npm, linuxbrew) and repos/ are excluded.
+    """
+    workspace_root = _resolve_workspace()
+    try:
+        svc = container.build_export_service(workspace_root)
+        options = ExportOptions(
+            output=output,
+            include_reports=include_reports,
+            exclude_mnt=exclude_mnt,
+            list_only=list_only,
+        )
+        result = svc.run(options)
+    except DadaiaError as e:
+        err_console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1) from None
+
+    if list_only:
+        return
+
+    size_kb = result.size // 1024
+    console.print(f"[green]✓[/green] {result.path}  ({size_kb} KB)")

dadaia_workspace-0.1.0/dadaia_workspace/cli/commands/import_.py

@@ -0,0 +1,89 @@
+"""dadaia import command."""
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from dadaia_workspace.core.models.import_ import ImportOptions
+from dadaia_workspace.features.import_.service import ImportService
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+def import_workspace(
+    archive: Annotated[
+        Path,
+        typer.Argument(help="Path to the .tar.gz archive generated by 'dadaia export'."),
+    ],
+    workspace: Annotated[
+        Path | None,
+        typer.Option("--workspace", "-w", help="Destination workspace root (default: cwd)."),
+    ] = None,
+    skip_mnt: Annotated[
+        bool,
+        typer.Option("--skip-mnt", help="Do not extract mnt/ container volumes."),
+    ] = False,
+    skip_activate: Annotated[
+        bool,
+        typer.Option(
+            "--skip-activate",
+            help="Skip context activation; leave all contexts as inativo.",
+        ),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview what would happen without changing anything."),
+    ] = False,
+) -> None:
+    """Import a workspace from a dadaia export archive.
+
+    Extracts the archive, patches absolute paths for the new workspace root,
+    runs 'dadaia init', and re-activates all contexts that were active at
+    export time.
+
+    Typical usage on a new machine after cloning dadaia-workspace and running
+    'pip install -e .':
+
+    \b
+        cd ~/workspace
+        dadaia import /path/to/workspace-2026-05-12-100000.tar.gz
+        dadaia import /path/to/workspace-2026-05-12-100000.tar.gz --skip-mnt
+    """
+    resolved_workspace = (workspace or Path.cwd()).resolve()
+    options = ImportOptions(
+        archive=archive.resolve(),
+        workspace=resolved_workspace,
+        skip_mnt=skip_mnt,
+        skip_activate=skip_activate,
+        dry_run=dry_run,
+    )
+
+    try:
+        svc = ImportService(workspace_root=resolved_workspace)
+        result = svc.run(options)
+    except ValueError as exc:
+        err_console.print(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(1) from None
+
+    if dry_run:
+        return
+
+    console.print(f"\n[green]✓[/green] Workspace imported at [bold]{result.workspace_root}[/bold]")
+    console.print(f"  Source: {options.archive.name}")
+
+    if result.contexts_restored:
+        console.print(f"\nContexts restored ({len(result.contexts_restored)}):")
+        for name in result.contexts_restored:
+            console.print(f"  [green]✓[/green] {name}")
+
+    if result.errors:
+        console.print("\n[yellow]Activation errors (check network/git access):[/yellow]")
+        for err in result.errors:
+            console.print(f"  [red]✗[/red] {err}")
+
+    console.print("\n[dim]Next steps:[/dim]")
+    console.print("  [dim]• Add secrets to services/conf/*.env (not included in export)[/dim]")
+    console.print("  [dim]• Run 'dadaia doctor' to verify workspace consistency[/dim]")

dadaia_workspace-0.1.0/dadaia_workspace/cli/commands/init.py

@@ -0,0 +1,51 @@
+"""dadaia init command."""
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from dadaia_workspace import container
+
+console = Console()
+app = typer.Typer()
+
+
+def _resolve_workspace(workspace: Path | None) -> Path:
+    if workspace:
+        return workspace.resolve()
+    # Walk up from CWD looking for .claude/ or .dadaia/
+    cwd = Path.cwd()
+    for parent in [cwd, *cwd.parents]:
+        if (parent / ".claude").exists() or (parent / ".dadaia").exists():
+            return parent
+    return cwd
+
+
+@app.command()
+def init(
+    workspace: Path | None = typer.Option(None, "--workspace", "-w", help="Workspace root path"),
+    skip_assets: bool = typer.Option(
+        False, "--skip-assets", help="Skip installing public agent assets"
+    ),
+) -> None:
+    """Bootstrap a dadaia workspace: creates .dadaia/ and installs agent assets into .claude/."""
+    root = _resolve_workspace(workspace)
+    console.print(f"[bold]Initializing workspace:[/bold] {root}")
+
+    svc = container.build_workspace_service(root)
+    _, installed = svc.init(root, skip_assets=skip_assets)
+
+    console.print(f"[green]✓[/green] .dadaia/ bootstrapped at {root / '.dadaia'}")
+
+    if skip_assets:
+        console.print("[dim]Skipped public asset installation (--skip-assets)[/dim]")
+    else:
+        if installed:
+            console.print(
+                f"[green]✓[/green] Installed {len(installed)} asset(s) into {root / '.claude'}"
+            )
+            for item in installed:
+                console.print(f"  {item}")
+        else:
+            console.print("[dim]No new assets to install (all up to date)[/dim]")