campfire-cli 0.1.0__py3-none-any.whl

campfire_cli/app/workspace/cli/workspace_cli.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from pathlib import Path
+
+import typer
+from pydantic import BaseModel
+
+from campfire_cli.app.workspace.repository.workspace_repository import SqliteWorkspaceRepository
+from campfire_cli.app.workspace.schema.workspace_schema import WorkspaceCreateRequest
+from campfire_cli.app.workspace.service.workspace_service import WorkspaceService
+from campfire_cli.common.exceptions import AppError
+from campfire_cli.config.settings import campfire_home
+
+workspace_cli = typer.Typer(
+    help="注册、初始化和解析多个 Workspace",
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+
+
+def service() -> WorkspaceService:
+    root = campfire_home()
+    return WorkspaceService(root, SqliteWorkspaceRepository(root))
+
+
+def emit(result: BaseModel) -> None:
+    typer.echo(json.dumps(result.model_dump(mode="json"), ensure_ascii=False, indent=2))
+
+
+def invoke[ResultT: BaseModel](operation: Callable[[], ResultT]) -> ResultT:
+    try:
+        return operation()
+    except AppError as exc:
+        typer.echo(
+            json.dumps({"status": "error", "message": str(exc)}, ensure_ascii=False), err=True
+        )
+        raise typer.Exit(exc.exit_code) from exc
+
+
+def initialize(workspace_id: str, path: Path, make_default: bool) -> BaseModel:
+    return invoke(
+        lambda: service().add(
+            WorkspaceCreateRequest(workspace_id=workspace_id, path=path, make_default=make_default)
+        )
+    )
+
+
+def setup_workspace(path: Path, make_default: bool) -> BaseModel:
+    return invoke(lambda: service().setup(path, make_default))
+
+
+@workspace_cli.command("add")
+def add(
+    workspace_id: str = typer.Option(..., "--id"),
+    path: Path = typer.Option(..., "--path"),
+    make_default: bool = typer.Option(False, "--default"),
+) -> None:
+    """注册并初始化一个已存在的 Workspace。"""
+    emit(initialize(workspace_id, path, make_default))
+
+
+@workspace_cli.command("attach")
+def attach(
+    path: Path = typer.Option(..., "--path"),
+    make_default: bool = typer.Option(False, "--default"),
+) -> None:
+    """根据 Vault 根目录的 .campfire.yaml 接入本机。"""
+    emit(setup_workspace(path, make_default))
+
+
+@workspace_cli.command("create")
+def create(
+    workspace_id: str = typer.Option(..., "--id"),
+    path: Path = typer.Option(..., "--path"),
+    make_default: bool = typer.Option(False, "--default"),
+) -> None:
+    """从零创建 Workspace 基础目录，并注册和初始化治理能力。"""
+    request = WorkspaceCreateRequest(
+        workspace_id=workspace_id, path=path, make_default=make_default
+    )
+    emit(invoke(lambda: service().create(request)))
+
+
+@workspace_cli.command("list")
+def list_workspaces() -> None:
+    """列出所有注册的 Workspace。"""
+    emit(invoke(service().list))
+
+
+@workspace_cli.command("show")
+def show(workspace_id: str) -> None:
+    """显示一个 Workspace 的路径和本机状态目录。"""
+    emit(invoke(lambda: service().show(workspace_id)))
+
+
+@workspace_cli.command("resolve")
+def resolve(selector: str | None = typer.Option(None, "--workspace")) -> None:
+    """按显式选择、当前目录或默认值解析 Workspace。"""
+    emit(invoke(lambda: service().resolve(selector, Path.cwd())))
+
+
+@workspace_cli.command("set-default")
+def set_default(workspace_id: str) -> None:
+    """设置默认 Workspace。"""
+    emit(invoke(lambda: service().set_default(workspace_id)))
+
+
+@workspace_cli.command("rebuild")
+def rebuild(
+    workspace: str | None = typer.Option(None, "--workspace"),
+    confirm: bool = typer.Option(False, "--confirm"),
+) -> None:
+    """从 Manifest 和 Markdown SSOT 重建本机派生索引。"""
+    if not confirm:
+        typer.echo(
+            json.dumps(
+                {
+                    "status": "ready",
+                    "operation": "replace-workspace-derived-indexes",
+                    "write_performed": False,
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+        )
+        return
+    from campfire_cli.container import AppContainer
+
+    emit(invoke(lambda: AppContainer.build(workspace).maintenance.check(summary=True)))
+
+
+@workspace_cli.command("export")
+def export_registry(output: Path = typer.Option(..., "--output")) -> None:
+    """将 Workspace 与 Project 注册数据导出为 JSON 备份。"""
+    emit(invoke(lambda: service().export_registry(output)))
+
+
+@workspace_cli.command("import")
+def import_registry(
+    input_path: Path = typer.Option(..., "--input"),
+    confirm: bool = typer.Option(False, "--confirm"),
+) -> None:
+    """校验注册数据备份；追加 --confirm 后替换当前注册数据。"""
+    emit(invoke(lambda: service().import_registry(input_path, confirm)))

campfire_cli/app/workspace/repository/__init__.py

@@ -0,0 +1 @@
+"""Workspace registry filesystem implementation."""

campfire_cli/app/workspace/repository/adoption_repository.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import json
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from campfire_cli.app.workspace.schema.adoption_schema import AdoptionBatchState
+from campfire_cli.common.database.models import AdoptionBatch
+from campfire_cli.common.exceptions import ConfigurationError
+
+
+class SqliteAdoptionRepository:
+    def __init__(self, session: Session, workspace_id: str) -> None:
+        self._session = session
+        self._workspace_id = workspace_id
+
+    def save(self, state: AdoptionBatchState) -> None:
+        row = self._row(state.batch)
+        if row is None:
+            row = AdoptionBatch(workspace_id=self._workspace_id, batch_name=state.batch)
+            self._session.add(row)
+        row.source_path = state.source_path
+        row.source_kind = state.source_kind
+        row.staging_path = state.staging_path
+        row.status = state.status
+        row.inventory_json = json.dumps(
+            [item.model_dump(mode="json") for item in state.inventory], ensure_ascii=False
+        )
+        row.plan_json = state.plan.model_dump_json() if state.plan else None
+        self._session.commit()
+
+    def load(self, batch: str) -> AdoptionBatchState:
+        row = self._row(batch)
+        if row is None:
+            raise ConfigurationError(f"接管批次不存在：{batch}")
+        return AdoptionBatchState(
+            batch=row.batch_name,
+            source_path=row.source_path,
+            source_kind=row.source_kind,
+            staging_path=row.staging_path,
+            status=row.status,
+            inventory=json.loads(row.inventory_json),
+            plan=json.loads(row.plan_json) if row.plan_json else None,
+        )
+
+    def _row(self, batch: str) -> AdoptionBatch | None:
+        if not batch or "/" in batch or "\\" in batch or batch in {".", ".."}:
+            raise ConfigurationError("非法接管批次名称")
+        return self._session.scalar(
+            select(AdoptionBatch).where(
+                AdoptionBatch.workspace_id == self._workspace_id,
+                AdoptionBatch.batch_name == batch,
+            )
+        )

campfire_cli/app/workspace/repository/manifest_repository.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+
+from campfire_cli.app.workspace.schema.workspace_schema import WorkspaceManifest
+from campfire_cli.common.exceptions import ConfigurationError
+from campfire_cli.common.filesystem import atomic_write
+
+MANIFEST_FILENAME = ".campfire.yaml"
+
+
+class WorkspaceManifestRepository:
+    """Read and write the portable Workspace metadata stored with a Vault."""
+
+    def path(self, workspace: Path) -> Path:
+        return workspace / MANIFEST_FILENAME
+
+    def load(self, workspace: Path) -> WorkspaceManifest | None:
+        target = self.path(workspace)
+        if not target.is_file():
+            return None
+        try:
+            payload = yaml.safe_load(target.read_text(encoding="utf-8")) or {}
+            return WorkspaceManifest.model_validate(payload)
+        except (yaml.YAMLError, ValueError) as exc:
+            raise ConfigurationError(f"Manifest 无效：{target}：{exc}") from exc
+
+    def save(self, workspace: Path, manifest: WorkspaceManifest) -> Path:
+        target = self.path(workspace)
+        content = yaml.safe_dump(
+            manifest.model_dump(mode="json", exclude_none=True),
+            allow_unicode=True,
+            sort_keys=False,
+        )
+        atomic_write(target, content)
+        return target

campfire_cli/app/workspace/repository/restructure_repository.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from campfire_cli.app.workspace.schema.restructure_schema import (
+    InventoryItem,
+    RestructurePlan,
+    RestructureResult,
+)
+from campfire_cli.common.database.models import RestructureBatch
+from campfire_cli.common.filesystem import atomic_write
+
+
+class SqliteRestructureRepository:
+    def __init__(self, session: Session, state_root: Path, workspace_id: str) -> None:
+        self._session = session
+        self._state_root = state_root
+        self._workspace_id = workspace_id
+
+    def save_batch(self, batch_uuid: str, batch: str, scope: str, config_hash: str) -> None:
+        existing = self._session.scalar(
+            select(RestructureBatch).where(
+                RestructureBatch.workspace_id == self._workspace_id,
+                RestructureBatch.batch_name == batch,
+            )
+        )
+        if existing is None:
+            self._session.add(
+                RestructureBatch(
+                    workspace_id=self._workspace_id,
+                    batch_uuid=batch_uuid,
+                    batch_name=batch,
+                    scope=scope,
+                    config_hash=config_hash,
+                )
+            )
+        else:
+            existing.scope = scope
+            existing.config_hash = config_hash
+        self._session.commit()
+
+    def save_inventory(self, batch: str, items: list[InventoryItem]) -> None:
+        payload = {
+            "schema_version": 1,
+            "batch": batch,
+            "items": [item.model_dump() for item in items],
+        }
+        self._write(batch, "inventory.json", payload)
+
+    def load_inventory(self, batch: str) -> tuple[str, str, list[InventoryItem]]:
+        row = self._session.scalar(
+            select(RestructureBatch).where(
+                RestructureBatch.workspace_id == self._workspace_id,
+                RestructureBatch.batch_name == batch,
+            )
+        )
+        if row is None:
+            raise ValueError(f"批次不存在：{batch}")
+        payload = self._read(batch, "inventory.json")
+        return (
+            row.scope,
+            row.config_hash,
+            [InventoryItem.model_validate(item) for item in payload["items"]],
+        )
+
+    def save_plan(self, plan: RestructurePlan) -> None:
+        self._write(plan.batch, "plan.json", plan.model_dump(mode="json"))
+
+    def load_plan(self, batch: str) -> RestructurePlan:
+        return RestructurePlan.model_validate(self._read(batch, "plan.json"))
+
+    def save_execution(self, result: RestructureResult) -> None:
+        self._write(result.batch, "execution.json", result.model_dump(mode="json"))
+
+    def save_verification(self, result: RestructureResult) -> None:
+        self._write(result.batch, "verification.json", result.model_dump(mode="json"))
+
+    def _path(self, batch: str, name: str) -> Path:
+        if not batch or "/" in batch or "\\" in batch or batch in {".", ".."}:
+            raise ValueError("非法批次名称")
+        return self._state_root / "batches" / batch / name
+
+    def _write(self, batch: str, name: str, payload: dict[str, object]) -> None:
+        atomic_write(
+            self._path(batch, name), json.dumps(payload, ensure_ascii=False, indent=2) + "\n"
+        )
+
+    def _read(self, batch: str, name: str) -> dict[str, object]:
+        return json.loads(self._path(batch, name).read_text(encoding="utf-8"))

campfire_cli/app/workspace/repository/workspace_repository.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from sqlalchemy import delete, select
+
+from campfire_cli.app.workspace.schema.workspace_schema import (
+    ProjectEntry,
+    WorkspaceEntry,
+    WorkspaceRegistry,
+)
+from campfire_cli.common.database import create_sqlite_engine, open_session, upgrade_database
+from campfire_cli.common.database.models import Project, Workspace
+
+
+class SqliteWorkspaceRepository:
+    """Persist the user-level Workspace and Project registry in SQLite."""
+
+    def __init__(self, governance_root: Path) -> None:
+        self._root = governance_root
+        database_path = governance_root / "campfire.db"
+        upgrade_database(database_path)
+        self._engine = create_sqlite_engine(database_path)
+
+    def load_registry(self) -> WorkspaceRegistry:
+        with open_session(self._engine) as session:
+            rows = session.scalars(select(Workspace).order_by(Workspace.id)).all()
+        default = next((row.id for row in rows if row.is_default), None)
+        return WorkspaceRegistry(
+            default_workspace=default,
+            workspaces={
+                row.id: WorkspaceEntry(path=row.path, status=row.status, default=row.is_default)
+                for row in rows
+            },
+        )
+
+    def save_registry(self, registry: WorkspaceRegistry) -> None:
+        with open_session(self._engine) as session, session.begin():
+            existing = {row.id: row for row in session.scalars(select(Workspace)).all()}
+            for workspace_id, entry in registry.workspaces.items():
+                row = existing.pop(workspace_id, None)
+                if row is None:
+                    row = Workspace(id=workspace_id, path=entry.path)
+                    session.add(row)
+                row.path = entry.path
+                row.status = entry.status
+                row.is_default = workspace_id == registry.default_workspace
+            for row in existing.values():
+                session.delete(row)
+
+    def list_projects(self, workspace_id: str | None = None) -> list[ProjectEntry]:
+        statement = select(Project).order_by(Project.workspace_id, Project.id)
+        if workspace_id is not None:
+            statement = statement.where(Project.workspace_id == workspace_id)
+        with open_session(self._engine) as session:
+            rows = session.scalars(statement).all()
+            return [self._project_entry(row) for row in rows]
+
+    def get_project(self, project_id: str) -> ProjectEntry | None:
+        with open_session(self._engine) as session:
+            row = session.get(Project, project_id)
+            return self._project_entry(row) if row else None
+
+    def save_project(self, project: ProjectEntry) -> str:
+        with open_session(self._engine) as session, session.begin():
+            row = session.get(Project, project.id)
+            operation = "updated" if row else "created"
+            if row is None:
+                row = Project(id=project.id, workspace_id=project.workspace_id)
+                session.add(row)
+            row.workspace_id = project.workspace_id
+            row.name = project.name
+            row.document_domain = project.document_domain
+            row.git_remote_url = project.git_remote_url
+            row.local_path = project.local_path
+            row.default_branch = project.default_branch
+            row.status = project.status
+        return operation
+
+    def replace_registry(self, registry: WorkspaceRegistry, projects: list[ProjectEntry]) -> None:
+        with open_session(self._engine) as session, session.begin():
+            session.execute(delete(Project))
+            session.execute(delete(Workspace))
+            for workspace_id, entry in registry.workspaces.items():
+                session.add(
+                    Workspace(
+                        id=workspace_id,
+                        path=entry.path,
+                        status=entry.status,
+                        is_default=workspace_id == registry.default_workspace,
+                    )
+                )
+            session.flush()
+            for project in projects:
+                session.add(
+                    Project(
+                        id=project.id,
+                        workspace_id=project.workspace_id,
+                        name=project.name,
+                        document_domain=project.document_domain,
+                        git_remote_url=project.git_remote_url,
+                        local_path=project.local_path,
+                        default_branch=project.default_branch,
+                        status=project.status,
+                    )
+                )
+
+    @staticmethod
+    def create_scaffold(root: Path, directories: tuple[str, ...]) -> list[str]:
+        for relative in directories:
+            (root / relative).mkdir(parents=True, exist_ok=True)
+        return list(directories)
+
+    @staticmethod
+    def _project_entry(row: Project) -> ProjectEntry:
+        return ProjectEntry(
+            id=row.id,
+            workspace_id=row.workspace_id,
+            name=row.name,
+            document_domain=row.document_domain,
+            git_remote_url=row.git_remote_url,
+            local_path=row.local_path,
+            default_branch=row.default_branch,
+            status=row.status,
+        )

campfire_cli/app/workspace/schema/__init__.py

@@ -0,0 +1 @@
+"""Workspace application schemas."""

campfire_cli/app/workspace/schema/adoption_schema.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class AdoptionInventoryItem(BaseModel):
+    path: str
+    sha256: str
+    size: int
+
+
+class AdoptionPlan(BaseModel):
+    batch: str
+    target_path: str
+    domain_id: str
+    name: str
+    space_id: str
+    domain_type: str
+    governance: str
+    parent_domain: str | None = None
+    project_id: str | None = None
+
+
+class AdoptionBatchState(BaseModel):
+    batch: str
+    source_path: str
+    source_kind: str
+    staging_path: str | None = None
+    status: str
+    inventory: list[AdoptionInventoryItem]
+    plan: AdoptionPlan | None = None
+
+
+class AdoptionResult(BaseModel):
+    status: str
+    batch: str
+    source: str
+    source_kind: str
+    staging_path: str | None = None
+    target_path: str | None = None
+    item_count: int = 0
+    copied_count: int = 0
+    operations: list[dict[str, str]] = Field(default_factory=list)
+    issues: list[dict[str, Any]] = Field(default_factory=list)
+    write_performed: bool = False

campfire_cli/app/workspace/schema/restructure_schema.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class InventoryItem(BaseModel):
+    path: str
+    sha256: str
+    size: int
+
+
+class RestructurePlanItem(BaseModel):
+    item_id: str
+    source: str
+    target: str
+    source_sha256: str
+    action: str
+    proposed_type: str | None = None
+    frontmatter: dict[str, Any] = Field(default_factory=dict)
+    reason: str
+    confidence: str
+    approved: bool = False
+
+
+class RestructurePlan(BaseModel):
+    schema_version: int = 1
+    batch: str
+    scope: str
+    config_hash: str
+    items: list[RestructurePlanItem] = Field(default_factory=list)
+
+
+class RestructureIntentItem(BaseModel):
+    source: str
+    target: str | None = None
+    frontmatter: dict[str, Any] = Field(default_factory=dict)
+    reason: str
+    approved: bool = False
+
+
+class RestructureIntentSpec(BaseModel):
+    schema_version: int = 1
+    operations: list[RestructureIntentItem]
+
+
+class RestructureResult(BaseModel):
+    status: str
+    batch: str
+    item_count: int
+    applied_count: int = 0
+    issues: list[dict[str, Any]] = Field(default_factory=list)
+
+
+class DomainRestructureResult(BaseModel):
+    status: str
+    domain_id: str
+    name: str
+    path: str
+    operations: list[dict[str, str]] = Field(default_factory=list)
+    affected_projects: list[str] = Field(default_factory=list)
+    write_performed: bool = False
+    issues: list[dict[str, Any]] = Field(default_factory=list)