dotbrain 0.3.4__py3-none-any.whl

dotbrain/workflows.py

@@ -0,0 +1,529 @@
+"""User-facing workflows that compose the concept modules (stage 5).
+
+These are the bodies behind ``dotbrain wire``, ``wire --all``, ``unwire``, and ``unwire --all``:
+cross-concept orchestration that stitches together ``adopter_repos`` (repo links),
+``brainspaces`` (Brain/workspace preparation, offboarding), ``beads`` (tracker init), ``skills``
+(skill manifest). ``cli.py`` stays a thin Typer parsing/rendering
+layer over these.
+
+The subprocess seams take an injected ``run`` callable so tests record argv instead of invoking
+``bd``/``git``.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from dotbrain import adopter_repos, beads, bootstrap, config, brainspaces, paths, skills, subagents
+from dotbrain.adopter_repos import UnwireResult, repo_for_brainspace, unwire_repo
+from dotbrain.beads import BootstrapResult
+from dotbrain.brainspaces import offboard_brainspace
+
+# A subprocess seam: same shape as ``subprocess.run`` but easy to fake in tests.
+Runner = Callable[..., "subprocess.CompletedProcess[str]"]
+
+
+def _default_run(
+    argv: Sequence[str], *, cwd: Path | None = None, env: dict | None = None, check: bool = True
+) -> "subprocess.CompletedProcess[str]":
+    # stdin=DEVNULL is load-bearing: bd auto-enables non-interactive mode on a non-TTY stdin,
+    # so destructive steps (e.g. bd init --reinit-local) skip their confirmation prompt instead
+    # of blocking forever on terminal input while capture_output swallows the prompt text.
+    return subprocess.run(
+        list(argv), cwd=cwd, env=env, check=check,
+        capture_output=True, encoding="utf-8", stdin=subprocess.DEVNULL,
+    )
+
+
+@dataclass
+class WireResult:
+    brainspace: Path
+    repo: Path | None = None
+    project: str = ""
+    logs: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+
+
+@dataclass
+class RefreshResult:
+    logs: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+    refreshed: list[str] = field(default_factory=list)
+
+
+def project_workspace_dirs(
+    brainspace: Path,
+    repo: Path | None,
+    workspaces: Sequence[str],
+    run: Runner = _default_run,
+) -> tuple[dict[str, Path], list[str]]:
+    """Resolve runtime workspace directories, materializing them in the adopter repo."""
+    directories: dict[str, Path] = {}
+    warnings: list[str] = []
+    for workspace in workspaces:
+        if repo is not None:
+            warning = adopter_repos.materialize_workspace(repo, brainspace, workspace, run)
+            if warning:
+                warnings.append(warning)
+                continue
+            directories[workspace] = repo / workspace
+        else:
+            directories[workspace] = brainspace / workspace
+    return directories, warnings
+
+
+def _reconcile_project_asset_excludes(
+    repo: Path | None,
+    *results: skills.LinkResult,
+    run: Runner = _default_run,
+) -> None:
+    if repo is None:
+        return
+    prefixes = (".claude/", ".codex/")
+    linked = [entry for result in results for entry in result.linked if entry.startswith(prefixes)]
+    pruned = [entry for result in results for entry in result.pruned if entry.startswith(prefixes)]
+    adopter_repos.reconcile_link_excludes(repo, linked=linked, pruned=pruned, run=run)
+
+
+def _link_project_assets(
+    dotbrain_home: Path,
+    brainspace: Path,
+    repo: Path | None,
+    workspaces: Sequence[str],
+    run: Runner = _default_run,
+) -> tuple[skills.LinkResult, skills.LinkResult, list[str]]:
+    workspace_dirs, warnings = project_workspace_dirs(brainspace, repo, workspaces, run)
+    active_workspaces = tuple(workspace_dirs)
+    skill_result = skills.link_project(
+        dotbrain_home,
+        brainspace,
+        active_workspaces,
+        skills.project_link_set(config.load_project_skills(dotbrain_home, brainspace.name)),
+        workspace_dirs=workspace_dirs,
+    )
+    subagent_result = subagents.link_project_subagents(
+        dotbrain_home,
+        brainspace,
+        active_workspaces,
+        subagents.project_link_set(config.load_project_subagents(dotbrain_home, brainspace.name)),
+        workspace_dirs=workspace_dirs,
+    )
+    _reconcile_project_asset_excludes(repo, skill_result, subagent_result, run=run)
+    return skill_result, subagent_result, warnings
+
+
+# --------------------------------------------------------------------------- wire one
+
+
+def wire_project(
+    *,
+    dotbrain_home: Path,
+    repo: Path | None = None,
+    project: str | None = None,
+    no_repo: bool = False,
+    run_beads: bool = True,
+    remote: str = "",
+    server_host: str = "",
+    server_port: str = "3307",
+    server_user: str = "beads",
+    database: str = "",
+    home: Path | None = None,
+    run: Runner = _default_run,
+) -> WireResult:
+    """Create/repair a Brainspace and wire an adopter repo. Mirrors wire-project.sh's main()."""
+    dotbrain_home = Path(dotbrain_home).resolve()
+    bootstrap.ensure_root_gitignore(dotbrain_home)
+    if not (dotbrain_home / ".git").exists():
+        raise RuntimeError(f"{dotbrain_home} is not a dotbrain git checkout")
+
+    resolved_repo: Path | None
+    if no_repo:
+        if not project:
+            raise ValueError("--no-repo requires --name <project>")
+        resolved_repo = None
+    else:
+        resolved_repo = adopter_repos.repo_root(repo, run)
+        project = project or resolved_repo.name
+
+    if resolved_repo is not None:
+        adopter_repos.ensure_not_wired_to_foreign_dotbrain(resolved_repo, dotbrain_home)
+
+    brainspace = paths.brainspace(dotbrain_home, project)
+    rel = paths.data_dir(dotbrain_home).name
+    archive = paths.data_dir(dotbrain_home) / ".archive" / project
+    unarchived = False
+    if archive.is_dir() and not brainspace.is_dir():
+        run(["git", "-C", str(dotbrain_home), "mv",
+             f"{rel}/.archive/{project}", f"{rel}/{project}"])
+        unarchived = True
+    brainspace.mkdir(parents=True, exist_ok=True)
+    if no_repo:
+        (brainspace / ".repo").write_text(
+            "(brain-only)\n", encoding="utf-8", newline="\n"
+        )
+    else:
+        assert resolved_repo is not None
+        (brainspace / ".repo").write_text(
+            f"{adopter_repos.abbrev_home(resolved_repo, home)}\n",
+            encoding="utf-8",
+            newline="\n",
+        )
+
+    result = WireResult(brainspace=brainspace, repo=resolved_repo, project=project)
+    if unarchived:
+        result.logs.append(f"unarchived {project} from {rel}/.archive/{project}")
+
+    brainspaces.seed_brain(brainspace, dotbrain_home)
+    config.migrate_legacy_skill_manifest(dotbrain_home, project)
+    active_workspaces = brainspaces.active_agent_workspaces(brainspace, dotbrain_home)
+    result.warnings += brainspaces.seed_agent_workspaces(brainspace, dotbrain_home, home)
+    skill_result, subagent_result, workspace_warnings = _link_project_assets(
+        dotbrain_home, brainspace, resolved_repo, active_workspaces, run
+    )
+    result.warnings += workspace_warnings + skill_result.warnings + subagent_result.warnings
+    result.logs += [f"pruned skill {entry}" for entry in skill_result.pruned]
+    result.logs += [f"pruned subagent {entry}" for entry in subagent_result.pruned]
+    beads_log = beads.init_beads(
+        brainspace, project, dotbrain_home,
+        run_beads=run_beads, remote=remote,
+        server_host=server_host, server_port=server_port,
+        server_user=server_user, database=database, run=run,
+    )
+    if beads_log:
+        result.logs.append(beads_log)
+    if run_beads:
+        # a deviating backend must be durable in project.yaml or hydration cannot
+        # reproduce it on a fresh clone
+        record_log = config.record_project_beads(
+            dotbrain_home, project,
+            config.ProjectBeads(
+                mode="server" if server_host else "embedded",
+                remote=remote,
+                database=database,
+            ),
+        )
+        if record_log:
+            result.logs.append(record_log)
+    result.logs.append(
+        f"Brainspace ready at {rel}/{project} (not committed); "
+        f"review and commit (suggested: feat(brain): wire {project})"
+    )
+
+    if no_repo:
+        result.logs.append(f"created brain-only Brainspace: {brainspace}")
+        return result
+
+    assert resolved_repo is not None
+    result.warnings += adopter_repos.wire_repo(
+        resolved_repo,
+        brainspace,
+        dotbrain_home,
+        run,
+        workspace_links=(),
+    )
+    if paths.INJECT_ADOPTER_POINTER:
+        result.warnings += adopter_repos.ensure_agent_context_pointer(resolved_repo)
+    expected_links = (".brain",)
+    if (brainspace / ".beads").exists():
+        expected_links += (".beads",)
+    result.warnings += adopter_repos.verify_wiring(
+        resolved_repo, run, expected_links=expected_links
+    )
+    result.logs.append(f"wired {project}")
+    return result
+
+
+# --------------------------------------------------------------------------- wire all
+
+
+def _repair_adopter_repo_links(
+    brainspace: Path, repo: Path, dotbrain_home: Path, run: Runner, *, skip_beads_link: bool = False
+) -> tuple[list[str], list[str]]:
+    git_marker = repo / ".git"
+    if not (git_marker.is_dir() or git_marker.is_file()):
+        return [], [f"{repo} is not a git repo; skipping"]
+
+    warnings = adopter_repos.wire_repo(
+        repo,
+        brainspace,
+        dotbrain_home,
+        run,
+        skip_beads_link=skip_beads_link,
+        workspace_links=(),
+    )
+    return [f"wired {brainspace.name} -> {repo}"], warnings
+
+
+def wire_all_projects(
+    dotbrain_home: Path,
+    repo_base: Path | None = None,
+    home: Path | None = None,
+    run: Runner = _default_run,
+) -> BootstrapResult:
+    """Re-seed brains from templates and repair agent workspace links for every
+    wired Brainspace.  Dotbrain-owned files (DOTBRAIN.md, README.md) are always
+    overwritten so template changes propagate.
+
+    Mirrors bootstrap.sh wire_brainspaces.
+    """
+    dotbrain_home = Path(dotbrain_home).resolve()
+    bootstrap.ensure_root_gitignore(dotbrain_home)
+    rb = repo_base or (Path.home() / "repos" / "projects")
+    result = BootstrapResult()
+    cfg = config.load_config(dotbrain_home)
+
+    for brainspace in paths.brainspaces(dotbrain_home):
+        brainspaces.seed_brain(brainspace, dotbrain_home)
+        # prepare declared agent workspaces before linking their assets
+        result.warnings += brainspaces.seed_agent_workspaces(brainspace, dotbrain_home, home)
+
+        repo = adopter_repos.repo_for_brainspace(brainspace, dotbrain_home, rb, home)
+        if repo is None:
+            if not brainspaces.is_brain_only(brainspace):
+                result.warnings.append(
+                    f"no repo found for Brainspace {brainspace.name}; "
+                    f"add {brainspace}/.repo or create {rb}/{brainspace.name}"
+                )
+            continue
+
+        active_workspaces = brainspaces.active_agent_workspaces(brainspace, dotbrain_home)
+        skill_result, subagent_result, workspace_warnings = _link_project_assets(
+            dotbrain_home, brainspace, repo, active_workspaces, run
+        )
+        result.warnings += workspace_warnings + skill_result.warnings + subagent_result.warnings
+        result.logs += [f"pruned skill {entry}" for entry in skill_result.pruned]
+        result.logs += [f"pruned subagent {entry}" for entry in subagent_result.pruned]
+
+        logs, warnings = _repair_adopter_repo_links(
+            brainspace, repo, dotbrain_home, run,
+            # a declared no-beads project never has a .beads dir; not a warning
+            skip_beads_link=config.load_project_config(dotbrain_home, brainspace.name).mode == "none",
+        )
+        result.logs += logs
+        result.warnings += warnings
+        if logs:
+            result.wired.append(str(repo))
+
+    return result
+
+
+# --------------------------------------------------------------------------- refresh
+
+
+def _brainspaces_for_refresh(dotbrain_home: Path, projects: Sequence[str] | None) -> list[Path]:
+    brainspaces = paths.brainspaces(dotbrain_home)
+    if projects is None:
+        return brainspaces
+
+    by_name = {brainspace.name: brainspace for brainspace in brainspaces}
+    selected: list[Path] = []
+    missing: list[str] = []
+    for project in projects:
+        brainspace = by_name.get(project)
+        if brainspace is None:
+            missing.append(project)
+        else:
+            selected.append(brainspace)
+    if missing:
+        raise ValueError(f"no Brainspace: {', '.join(missing)}")
+    return selected
+
+
+def refresh_projects(
+    dotbrain_home: Path,
+    *,
+    projects: Sequence[str] | None = None,
+    repo_base: Path | None = None,
+    home: Path | None = None,
+    workspaces: Sequence[str] = (".claude", ".codex"),
+    run: Runner = _default_run,
+) -> RefreshResult:
+    """Refresh project Brainspaces without creating or offboarding projects.
+
+    Composes the existing concept owners: Brain/workspace seeding, adopter-repo link repair,
+    beads load/hydration, and project skill linking.
+    """
+    dotbrain_home = Path(dotbrain_home).resolve()
+    if not (dotbrain_home / ".git").exists():
+        raise RuntimeError(f"{dotbrain_home} is not a dotbrain git checkout")
+
+    result = RefreshResult()
+    brainspace_paths = _brainspaces_for_refresh(dotbrain_home, projects)
+    cfg = config.load_config(dotbrain_home)
+    rb = repo_base or (Path.home() / "repos" / "projects")
+
+    for brainspace in brainspace_paths:
+        brainspaces.seed_brain(brainspace, dotbrain_home)
+        result.warnings += brainspaces.seed_agent_workspaces(brainspace, dotbrain_home, home)
+        migrate_log = config.migrate_legacy_skill_manifest(dotbrain_home, brainspace.name)
+        if migrate_log:
+            result.logs.append(migrate_log)
+        declared_workspaces = brainspaces.active_agent_workspaces(brainspace, dotbrain_home)
+        active_workspaces = tuple(ws for ws in workspaces if ws in declared_workspaces)
+        repo = repo_for_brainspace(brainspace, dotbrain_home, rb, home)
+        link_result, subagent_result, workspace_warnings = _link_project_assets(
+            dotbrain_home, brainspace, repo, active_workspaces, run
+        )
+        result.warnings += workspace_warnings
+        result.logs += [f"pruned skill {entry}" for entry in link_result.pruned]
+        result.logs += [f"stashed collision {path}" for path in link_result.stashed]
+        result.warnings += link_result.warnings
+        result.logs += [f"pruned subagent {entry}" for entry in subagent_result.pruned]
+        result.logs += [f"stashed subagent collision {path}" for path in subagent_result.stashed]
+        result.warnings += subagent_result.warnings
+        result.logs.append(
+            f"project: linked {len(subagent_result.linked)} subagent file(s) into {brainspace.name}"
+        )
+
+        if repo is None:
+            if not brainspaces.is_brain_only(brainspace):
+                result.warnings.append(
+                    f"no repo found for Brainspace {brainspace.name}; "
+                    f"add {brainspace}/.repo or create {rb}/{brainspace.name}"
+                )
+        else:
+            logs, warnings = _repair_adopter_repo_links(
+                brainspace,
+                repo,
+                dotbrain_home,
+                run,
+                skip_beads_link=config.load_project_config(dotbrain_home, brainspace.name).mode == "none",
+            )
+            result.logs += logs
+            result.warnings += warnings
+
+        result.refreshed.append(brainspace.name)
+        result.logs.append(f"refreshed {brainspace.name} ({len(link_result.linked)} skills linked)")
+
+    beads_result = beads.pull_beads_for_all(
+        dotbrain_home,
+        run=run,
+        projects=[brainspace.name for brainspace in brainspace_paths],
+    )
+    result.logs += beads_result.logs
+    result.warnings += beads_result.warnings
+    return result
+
+
+def refresh_project(
+    dotbrain_home: Path,
+    project: str,
+    *,
+    repo_base: Path | None = None,
+    home: Path | None = None,
+    workspaces: Sequence[str] = (".claude", ".codex"),
+    run: Runner = _default_run,
+) -> RefreshResult:
+    """Refresh one project Brainspace without creating or offboarding it."""
+    return refresh_projects(
+        dotbrain_home,
+        projects=[project],
+        repo_base=repo_base,
+        home=home,
+        workspaces=workspaces,
+        run=run,
+    )
+
+
+def _resolve_project(repo: Path, project: str | None) -> str:
+    """Infer project name from the .brain symlink target; fall back to repo dir name."""
+    brain = repo / ".brain"
+    if not project and brain.is_symlink():
+        project = brain.resolve().parent.name
+    return project or repo.name
+
+
+def _repo_root(repo: Path | None, run: Runner) -> Path:
+    cwd = repo or Path.cwd()
+    result = run(["git", "-C", str(cwd), "rev-parse", "--show-toplevel"])
+    return Path(result.stdout.strip())
+
+
+def unwire_project(
+    *,
+    dotbrain_home: Path,
+    repo: Path | None = None,
+    project: str | None = None,
+    no_repo: bool = False,
+    offboard: str = "keep",
+    dry_run: bool = False,
+    run: Runner = _default_run,
+) -> UnwireResult:
+    """Disconnect an adopter repo from its dotbrain Brainspace and offboard the Brainspace.
+
+    Dropping a server-backend project's remote beads database is a separate, explicit step
+    (``beads.drop_remote_beads_database`` / the ``beads drop-db`` command).
+    """
+    dotbrain_home = Path(dotbrain_home).resolve()
+    if not (dotbrain_home / ".git").exists():
+        raise RuntimeError(f"{dotbrain_home} is not a dotbrain git checkout")
+
+    if no_repo:
+        if not project:
+            raise ValueError("--no-repo requires --name")
+        resolved_repo = None
+        result = UnwireResult(project=project, repo=None)
+    else:
+        resolved_repo = _repo_root(repo, run)
+        project = _resolve_project(resolved_repo, project)
+        result = unwire_repo(
+            resolved_repo, dry_run=dry_run, dotbrain_home=dotbrain_home, run=run
+        )
+        result.project = project
+    result.logs += offboard_brainspace(dotbrain_home, project, offboard, dry_run=dry_run, run=run)
+    if offboard in {"archive", "delete"} and not dry_run:
+        # the Brainspace is gone from projects/; a leftover entry would make
+        # bootstrap try to hydrate a non-existent project
+        removed = config.remove_project_beads(dotbrain_home, project)
+        if removed:
+            result.logs.append(removed)
+    result.logs.append(
+        f"unwired {project} (repo: {resolved_repo})\n"
+        "repo edits are not committed; review and commit if wanted"
+    )
+    return result
+
+
+def unwire_all_projects(
+    dotbrain_home: Path,
+    offboard: str = "keep",
+    dry_run: bool = False,
+    run: Runner = _default_run,
+) -> list[UnwireResult]:
+    """Unwire every project Brainspace. Continues on per-project failure.
+
+    ``offboard`` defaults to ``keep`` (Brainspaces are not destroyed in batch
+    mode). Mutually exclusive with ``--archive``/``--delete`` — use per-project
+    ``unwire`` for destructive offboard.
+    """
+    dotbrain_home = Path(dotbrain_home).resolve()
+    results: list[UnwireResult] = []
+    for brainspace in paths.brainspaces(dotbrain_home):
+        project = brainspace.name
+        try:
+            repo = repo_for_brainspace(brainspace, dotbrain_home)
+            if repo and repo.is_dir():
+                result = unwire_repo(repo, dry_run=dry_run, dotbrain_home=dotbrain_home, run=run)
+            else:
+                result = UnwireResult(project=project, repo=None)
+            result.project = project
+            result.logs += offboard_brainspace(
+                dotbrain_home, project, offboard, dry_run=dry_run, run=run,
+            )
+            if offboard in {"archive", "delete"} and not dry_run:
+                removed = config.remove_project_beads(dotbrain_home, project)
+                if removed:
+                    result.logs.append(removed)
+            result.logs.append(
+                f"unwired {project} (repo: {repo})"
+            )
+            results.append(result)
+        except Exception as exc:
+            results.append(UnwireResult(
+                project=project,
+                logs=[f"error unwiring {project}: {exc}"],
+            ))
+    return results

dotbrain-0.3.4.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.5
+Name: dotbrain
+Version: 0.3.4
+Summary: Wires project Brainspaces and skills into coding agents.
+Project-URL: Homepage, https://github.com/arminzou/dotbrain
+Project-URL: Repository, https://github.com/arminzou/dotbrain
+Project-URL: Issues, https://github.com/arminzou/dotbrain/issues
+Author: Armin Zou
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Requires-Dist: pyyaml>=6
+Requires-Dist: typer>=0.12

dotbrain-0.3.4.dist-info/RECORD

@@ -0,0 +1,40 @@
+dotbrain/__init__.py,sha256=HN1nRGcd7iLuIMOOXxlpWVRL8w1lfi176MNiI_5fpsQ,202
+dotbrain/_cli_reference.py,sha256=-uwqJ96WTbh4U7ptSwSA6JM2kD27G-p9q3GZc71h09c,4619
+dotbrain/adopter_repos.py,sha256=nFF4Ke1z_hcUA-L_UgjWXFtXAEd3t2haPnkLMeNO_J4,21080
+dotbrain/beads.py,sha256=wteGT6Op7MQtshdz60-T5vu5-Zn-21PEYakLPbigtds,20103
+dotbrain/bootstrap.py,sha256=srBotcoROGcxFWsdYZBsegBAxutVdO01r033V1XHuvM,7609
+dotbrain/brainspaces.py,sha256=yqEhAZEBHnn5JkRw3RWjJDlnr-yQvFASl6z5kwxiPTk,9257
+dotbrain/cli.py,sha256=QUJKud1JPgnOzYidgywcmv4uYo8JojlO6fEW-4i5tgI,29863
+dotbrain/config.py,sha256=5ZLFKMwIru8VrSRAMMWWV8X_aPfJzRvu2ktygWOXeKU,15600
+dotbrain/doctor.py,sha256=KBGuPCPn5ternVQcFSr7_hav7nrPWM2UHCcMNGoHSgc,10892
+dotbrain/hooks.py,sha256=-RttCq5QbgnaK6RKzo8nkIq98i2tAHTf-x8POyMDVKY,3108
+dotbrain/migrate.py,sha256=lSVuKPbnvL_0xiclKTAlAy8Q_9SxTPU7jHKRdqyTWS4,11953
+dotbrain/paths.py,sha256=H9oddr2S3jiVlAnAhb-xqJ9bWXmPD3F1j6Fgb_8yPJU,5318
+dotbrain/resource_loader.py,sha256=vz88YCw-e3Thq880x2SV2VnzqAbitoli4Suw7SidKLw,1428
+dotbrain/skills.py,sha256=_C4HjRoJkKKSYUTLL-hmESIf4QGX5tfVbKTdgg0YBbU,8147
+dotbrain/subagents.py,sha256=43p6JEezGZgC4JGgn3sZYQxm8IIz9s2nPH2SuKIa45g,8513
+dotbrain/updater.py,sha256=0S3HcJEyE2C4UHezEFThoAJbsIDGPjreaBJC_J4dnHU,3576
+dotbrain/workflows.py,sha256=r68EtJxsK1R_H1fT4AXQKz4EYCQp_-1L6iqqj3cMHqE,20374
+dotbrain/resources/__init__.py,sha256=5wg3Qaq5N7goIs7n4wB1Omzs1bW9Ui9YlMbUTLO4_Iw,41
+dotbrain/resources/config.yaml,sha256=jHtMw_jxaMIMWSZvyYXWlFj1Vz2mYc7p9UNW3VuilmA,995
+dotbrain/resources/core.yaml,sha256=hP1_4nJWptFgP4VTFOkv5c2AhROBDJApndl2TsSHjq8,658
+dotbrain/resources/agents/claude/implementer.md,sha256=WCBdZn3hGhbdNMWCArArCvAu8HRRkVEbL8NHewlUIlM,2433
+dotbrain/resources/agents/claude/investigator.md,sha256=piBUF4tQwAmGBhUjwlqAUgvDKQmh-XOin-vpgJwCGB4,1468
+dotbrain/resources/agents/claude/reviewer.md,sha256=j3czU-ykZeTGALjtJS1XaoGzP3bY6ltN9OSmRdxqQgk,1848
+dotbrain/resources/agents/claude/verifier.md,sha256=PaNt5tzs2hPXBR0fmCV6Z0GHlWmNObsBvtFzncYV0cY,1583
+dotbrain/resources/agents/codex/implementer.toml,sha256=4axdxDDojpiRMPxrRW4uo28gMbfizrB0pvZ0Gd-K-lA,1345
+dotbrain/resources/agents/codex/investigator.toml,sha256=rMBZWHKR_RbYWEpn-96LmaiIcgexNPt88JrIe5dZyUo,977
+dotbrain/resources/agents/codex/reviewer.toml,sha256=4Dxr6xKO3O5jLTTx9FMGhQhFoYJlhVykksvJtz8AdkE,1545
+dotbrain/resources/agents/codex/verifier.toml,sha256=1SqQ-GX4WbScQ81nUoX8Nsi2voG18NmRnwwlfkQWncE,1028
+dotbrain/resources/templates/gitignore,sha256=fKOqYIasov03QWzLnmLEH7K98ldvVQ850TLf6wgPRdI,477
+dotbrain/resources/templates/brain/AGENTS.md,sha256=coraxjZ4NtPEk3mhJY3Bw59dd0MT-OJt_Qyf4e05bZc,828
+dotbrain/resources/templates/brain/DOTBRAIN.md,sha256=X40SGuKLD7w7PkO2dbnP3zNlyaYzANlFQmNWAmC3-9E,6860
+dotbrain/resources/templates/brain/project.yaml,sha256=9e2Z_fVxYeQ0SBQ7OhqxPQRfxZcAxI1bAva_xSh9JEY,931
+dotbrain/resources/templates/brain/adr/README.md,sha256=6D3TlAlcKu3qdYsmYvRH2mKM_vFRhLqLB_tga4-Zj1Q,285
+dotbrain/resources/templates/brain/designs/README.md,sha256=mQDEkw_NHgd_PlvpJbvtxO4bab_bZgedbXm2jrcMJEc,1571
+dotbrain/resources/templates/brain/docs/README.md,sha256=D2GcjZEMv6HLm6mLeuNj8vKYW_fzRRfHtSqvoZm4CjA,361
+dotbrain-0.3.4.dist-info/METADATA,sha256=5GW8h-MR4KyV4d9XXHWyAD1HRusME1XaY1vOWfutkeg,832
+dotbrain-0.3.4.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+dotbrain-0.3.4.dist-info/entry_points.txt,sha256=xFOB2wF9P8j5XZzg1JmVevJMZArPxLNjfrsRXU20AXM,46
+dotbrain-0.3.4.dist-info/licenses/LICENSE,sha256=dNK42nSumWv628_jEFn1wbwoHlwaeHQXJKlsvewyGbc,1066
+dotbrain-0.3.4.dist-info/RECORD,,

dotbrain-0.3.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

dotbrain-0.3.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dotbrain = dotbrain.cli:app

dotbrain-0.3.4.dist-info/licenses/LICENSE

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