kanibako-cli 1.5.0.dev14__py3-none-any.whl

kanibako/commands/archive.py

@@ -0,0 +1,228 @@
+"""kanibako archive: archive session data + git metadata to .txz."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+
+from kanibako.config import config_file_path, load_config
+from kanibako.errors import GitError
+from kanibako.git import check_uncommitted, check_unpushed, get_metadata, is_git_repo
+from kanibako.paths import xdg, load_std_paths, resolve_any_project
+
+
+def add_parser(subparsers: argparse._SubParsersAction) -> None:
+    p = subparsers.add_parser(
+        "archive",
+        help="Archive project session data to .txz file",
+        description="Archive project session data and git metadata to a .txz file.",
+    )
+    p.add_argument("path", nargs="?", default=None, help="Path to the project directory")
+    p.add_argument("file", nargs="?", default=None, help="Output filename (default: auto-generated)")
+    p.add_argument(
+        "--all", action="store_true", dest="all_projects",
+        help="Archive session data for every known project",
+    )
+    p.add_argument("--allow-uncommitted", action="store_true",
+                    help="Allow archiving with uncommitted changes")
+    p.add_argument("--allow-unpushed", action="store_true",
+                    help="Allow archiving with unpushed commits")
+    p.add_argument("--force", action="store_true", help="Skip all confirmation prompts")
+    p.set_defaults(func=run)
+
+
+def run(args: argparse.Namespace) -> int:
+    config_file = config_file_path(xdg("XDG_CONFIG_HOME", ".config"))
+    config = load_config(config_file)
+    std = load_std_paths(config)
+
+    if args.all_projects:
+        return _archive_all(std, config, args)
+
+    if args.path is None:
+        print("Error: specify a project path, or use --all", file=sys.stderr)
+        return 1
+
+    proj = resolve_any_project(std, config, project_dir=args.path, initialize=False)
+    return _archive_one(std, config, proj, output_file=args.file, args=args)
+
+
+def _archive_one(std, config, proj, *, output_file, args) -> int:
+    """Archive session data for a single project."""
+    if not proj.metadata_path.is_dir():
+        print(f"Error: No session data found for project {proj.project_path}", file=sys.stderr)
+        return 1
+
+    # Generate default archive filename
+    archive_file = output_file
+    if not archive_file:
+        label = proj.name or proj.project_path.name
+        timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+        archive_file = f"kanibako-{label}-{timestamp}.txz"
+
+    # Prepare metadata
+    info_file = proj.metadata_path / "kanibako-archive-info.txt"
+    lines = [
+        f"Project path: {proj.project_path}",
+        f"Project hash: {proj.project_hash}",
+        f"Archive date: {datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')}",
+        "",
+    ]
+
+    # Git checks (only if project path exists on disk)
+    if proj.project_path.is_dir() and is_git_repo(proj.project_path):
+        if not args.allow_uncommitted:
+            try:
+                check_uncommitted(proj.project_path)
+            except GitError as e:
+                print(f"Error: {e}", file=sys.stderr)
+                return 1
+
+        if not args.allow_unpushed:
+            try:
+                check_unpushed(proj.project_path)
+            except GitError as e:
+                print(f"Error: {e}", file=sys.stderr)
+                return 1
+
+        meta = get_metadata(proj.project_path)
+        if meta:
+            lines.append("Git repository: yes")
+            lines.append(f"Branch: {meta.branch}")
+            lines.append(f"Commit: {meta.commit}")
+            lines.append("Remotes:")
+            for name, url in meta.remotes:
+                lines.append(f"  {name}: {url}")
+    else:
+        if proj.project_path.is_dir():
+            print(
+                f"Warning: No git repository detected in {proj.project_path}",
+                file=sys.stderr,
+            )
+            print("Only kanibako session data will be archived.", file=sys.stderr)
+        lines.append("")
+        lines.append("Git repository: no")
+
+    info_file.write_text("\n".join(lines) + "\n")
+
+    # Create archive using Python tarfile
+    print(f"Creating archive {archive_file}... ", end="", flush=True)
+    try:
+        with tarfile.open(archive_file, "w:xz") as tar:
+            tar.add(
+                str(proj.metadata_path),
+                arcname=proj.project_hash,
+            )
+    except Exception as e:
+        info_file.unlink(missing_ok=True)
+        print(f"\nError: Failed to create archive: {e}", file=sys.stderr)
+        return 1
+    finally:
+        info_file.unlink(missing_ok=True)
+
+    print("done.")
+    print(f"Archive created: {archive_file}")
+    return 0
+
+
+def _archive_all(std, config, args) -> int:
+    """Archive session data for all known projects."""
+    from kanibako.paths import (
+        WorksetSpec,
+        iter_projects,
+        iter_workset_projects,
+        resolve_project,
+        resolve_workset_project,
+    )
+
+    projects = iter_projects(std, config)
+    ws_data = iter_workset_projects(std, config)
+
+    if not projects and not ws_data:
+        print("No project session data found.")
+        return 0
+
+    total = len(projects)
+    for _, _, project_list in ws_data:
+        total += sum(1 for _, status in project_list if status != "no-data")
+
+    print(f"Found {total} project(s) to archive:")
+    for metadata_path, project_path in projects:
+        label = str(project_path) if project_path else f"(unknown) {metadata_path.name[:8]}"
+        print(f"  {label}")
+    for ws_name, ws, project_list in ws_data:
+        for proj_name, status in project_list:
+            if status != "no-data":
+                print(f"  {ws_name}/{proj_name}")
+    print()
+
+    archived = 0
+    failed = 0
+
+    # Default-mode projects.
+    for metadata_path, project_path in projects:
+        if project_path:
+            try:
+                proj = resolve_project(
+                    std, config, project_dir=str(project_path), initialize=False
+                )
+            except Exception:
+                proj = _stub_project(metadata_path, project_path, config)
+        else:
+            proj = _stub_project(metadata_path, None, config)
+
+        rc = _archive_one(std, config, proj, output_file=None, args=args)
+        if rc == 0:
+            archived += 1
+        else:
+            failed += 1
+
+    # Workset projects.
+    for ws_name, ws, project_list in ws_data:
+        for proj_name, status in project_list:
+            if status == "no-data":
+                continue
+            try:
+                proj = resolve_workset_project(
+                    WorksetSpec.from_workset(ws), proj_name, std, config, initialize=False,
+                )
+            except Exception:
+                failed += 1
+                continue
+            rc = _archive_one(std, config, proj, output_file=None, args=args)
+            if rc == 0:
+                archived += 1
+            else:
+                failed += 1
+
+    print(f"\nArchived {archived} project(s).", end="")
+    if failed:
+        print(f" {failed} failed.", end="")
+    print()
+    return 1 if failed else 0
+
+
+def _stub_project(metadata_path, project_path, config):
+    """Create a minimal ProjectPaths stand-in for projects whose path is gone."""
+    from kanibako.config import read_project_meta
+    from kanibako.paths import ProjectPaths
+
+    # Read hash and name from project.yaml when available.
+    meta = read_project_meta(metadata_path / "project.yaml")
+    phash = (meta.get("project_hash") or metadata_path.name) if meta else metadata_path.name
+    name = (meta.get("name") or "") if meta else ""
+
+    effective_path = project_path or Path(f"(unknown-{name or metadata_path.name})")
+    return ProjectPaths(
+        project_path=effective_path,
+        project_hash=phash,
+        metadata_path=metadata_path,
+        shell_path=metadata_path / "shell",
+        vault_ro_path=effective_path / "vault" / "ro",
+        vault_rw_path=effective_path / "vault" / "rw",
+        is_new=False,
+        name=name,
+    )

kanibako/commands/box/__init__.py

@@ -0,0 +1,22 @@
+"""kanibako box: project lifecycle management (create, list, config, migrate, duplicate, move, archive, extract, purge, vault)."""
+
+from kanibako.commands.box._duplicate import run_duplicate
+from kanibako.commands.box._migrate import run_migrate
+from kanibako.commands.box._parser import (
+    _check_container_running,
+    _format_credential_age,
+    add_parser,
+    run_config,
+    run_create,
+    run_info,
+    run_list,
+    run_move,
+    run_ps,
+    run_rm,
+)
+
+__all__ = [
+    "_check_container_running", "_format_credential_age",
+    "add_parser", "run_config", "run_create", "run_duplicate",
+    "run_info", "run_list", "run_migrate", "run_move", "run_ps", "run_rm",
+]

kanibako/commands/box/_duplicate.py

@@ -0,0 +1,395 @@
+"""Duplicate logic for kanibako box."""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import sys
+from pathlib import Path
+
+from kanibako.config import config_file_path, load_config
+from kanibako.names import assign_name
+from kanibako.paths import (
+    ProjectMode,
+    WorksetSpec,
+    _find_workset_for_path,
+    _resolve_local_dir,
+    xdg,
+    detect_project_mode,
+    load_std_paths,
+    resolve_standalone_project,
+    resolve_project,
+    resolve_workset_project,
+)
+from kanibako.utils import confirm_prompt
+
+
+# -- Cross-mode duplicate helpers --
+
+def _run_duplicate_cross_mode(args: argparse.Namespace, std, config) -> int:
+    """Duplicate a project into a different mode layout."""
+    to_mode_str = args.to_mode
+
+    # Duplicate TO workset: separate code path.
+    if to_mode_str == "workset":
+        return _duplicate_to_workset(args, std, config)
+
+    source_path = Path(args.source_path).resolve()
+    new_path = Path(args.new_path).resolve()
+
+    if source_path == new_path:
+        print("Error: source and destination paths are the same.", file=sys.stderr)
+        return 1
+
+    if not source_path.is_dir():
+        print(f"Error: source path does not exist as a directory: {source_path}", file=sys.stderr)
+        return 1
+
+    # Detect source mode and resolve.
+    source_mode = detect_project_mode(source_path, std, config).mode
+
+    # Duplicate FROM workset: separate code path.
+    if source_mode == ProjectMode.workset:
+        return _duplicate_from_workset(args, source_path, new_path, std, config)
+
+    # default<->standalone: architectural boundary (centralized vs in-workspace metadata), not re-rooting — kept distinct (#71 B2).
+    if source_mode == ProjectMode.default:
+        src_proj = resolve_project(std, config, project_dir=str(source_path), initialize=False)
+    else:
+        src_proj = resolve_standalone_project(std, config, project_dir=str(source_path), initialize=False)
+
+    if not src_proj.metadata_path.is_dir():
+        print(f"Error: no project data found for source path: {source_path}", file=sys.stderr)
+        return 1
+
+    # Lock file warning.
+    lock_file = src_proj.metadata_path / ".kanibako.lock"
+    if lock_file.exists():
+        print(
+            "Warning: lock file found — a container may be running for this project.",
+            file=sys.stderr,
+        )
+        if not args.force:
+            print("Aborted.")
+            return 2
+
+    # Confirm with user.
+    target_mode = ProjectMode.standalone if to_mode_str == "standalone" else ProjectMode.default
+    if not args.force:
+        mode = "metadata only (bare)" if args.bare else "workspace + metadata"
+        print(f"Duplicate project ({mode}) to {target_mode.value} mode:")
+        print(f"  from: {source_path}")
+        print(f"    to: {new_path}")
+        print()
+        try:
+            confirm_prompt("Type 'yes' to confirm: ")
+        except Exception:
+            print("Aborted.")
+            return 2
+
+    # Copy workspace (unless --bare).
+    if not args.bare:
+        shutil.copytree(source_path, new_path, dirs_exist_ok=args.force)
+
+    # Copy metadata into target mode layout.
+    # default<->standalone: architectural boundary (centralized vs in-workspace metadata), not re-rooting — kept distinct (#71 B2).
+    if target_mode == ProjectMode.standalone:
+        _duplicate_to_standalone(src_proj, new_path, args.force)
+    else:
+        _duplicate_to_local(src_proj, new_path, std, config, args.force)
+
+    print(f"Duplicated project to {target_mode.value} mode:")
+    print(f"  from: {source_path}")
+    print(f"    to: {new_path}")
+    return 0
+
+
+def _duplicate_to_standalone(src_proj, new_path, force):
+    """Copy metadata into standalone layout at new_path."""
+    from kanibako.utils import write_project_gitignore
+
+    dst_metadata = new_path / ".kanibako"
+    dst_shell = dst_metadata / "shell"
+
+    # Ensure new_path exists for bare duplicates.
+    new_path.mkdir(parents=True, exist_ok=True)
+
+    if force and dst_metadata.is_dir():
+        shutil.rmtree(dst_metadata)
+    shutil.copytree(
+        src_proj.metadata_path, dst_metadata,
+        ignore=shutil.ignore_patterns(".kanibako.lock", "shell"),
+    )
+
+    if src_proj.shell_path.is_dir():
+        if force and dst_shell.is_dir():
+            shutil.rmtree(dst_shell)
+        shutil.copytree(src_proj.shell_path, dst_shell)
+
+    write_project_gitignore(new_path)
+
+    # Write vault .gitignore if vault exists.
+    vault_dir = new_path / "vault"
+    if vault_dir.is_dir():
+        vault_gitignore = vault_dir / ".gitignore"
+        if not vault_gitignore.exists():
+            vault_gitignore.write_text("rw/\n")
+
+
+def _duplicate_to_local(src_proj, new_path, std, config, force):
+    """Copy metadata into default-mode layout for new_path."""
+    # Assign a new name for the duplicate.
+    project_name = assign_name(std.data_path, str(new_path))
+    projects_base = std.boxes
+    dst_project = projects_base / project_name
+
+    if force and dst_project.is_dir():
+        shutil.rmtree(dst_project)
+    shutil.copytree(
+        src_proj.metadata_path, dst_project,
+        ignore=shutil.ignore_patterns(".kanibako.lock"),
+    )
+
+    # Ensure home is inside the project dir.
+    if src_proj.shell_path.is_dir():
+        dst_home = dst_project / "shell"
+        if not dst_home.is_dir():
+            shutil.copytree(src_proj.shell_path, dst_home)
+
+
+def _duplicate_to_workset(args, std, config) -> int:
+    """Duplicate a project into a workset (source untouched)."""
+    from kanibako.commands.box._migrate import _copy_into_workset
+    from kanibako.workset import list_worksets, load_workset
+
+    ws_name = getattr(args, "workset", None)
+    if not ws_name:
+        print("Error: --workset is required when duplicating to workset mode.", file=sys.stderr)
+        return 1
+
+    registry = list_worksets(std)
+    if ws_name not in registry:
+        print(f"Error: workset '{ws_name}' not found.", file=sys.stderr)
+        return 1
+    ws = load_workset(registry[ws_name])
+
+    source_path = Path(args.source_path).resolve()
+    if not source_path.is_dir():
+        print(f"Error: source path does not exist as a directory: {source_path}", file=sys.stderr)
+        return 1
+
+    source_mode = detect_project_mode(source_path, std, config).mode
+    if source_mode == ProjectMode.workset:
+        print("Error: source is already a workset project.", file=sys.stderr)
+        return 1
+
+    proj_name = getattr(args, "project_name", None) or source_path.name
+
+    # Validate name not taken.
+    for p in ws.projects:
+        if p.name == proj_name:
+            print(f"Error: project '{proj_name}' already exists in workset '{ws_name}'.", file=sys.stderr)
+            return 1
+
+    # default<->standalone: architectural boundary (centralized vs in-workspace metadata), not re-rooting — kept distinct (#71 B2).
+    if source_mode == ProjectMode.default:
+        src_proj = resolve_project(std, config, project_dir=str(source_path), initialize=False)
+    else:
+        src_proj = resolve_standalone_project(std, config, project_dir=str(source_path), initialize=False)
+
+    if not src_proj.metadata_path.is_dir():
+        print(f"Error: no project data found for source path: {source_path}", file=sys.stderr)
+        return 1
+
+    # Lock file warning.
+    lock_file = src_proj.metadata_path / ".kanibako.lock"
+    if lock_file.exists():
+        print(
+            "Warning: lock file found — a container may be running for this project.",
+            file=sys.stderr,
+        )
+        if not args.force:
+            print("Aborted.")
+            return 2
+
+    if not args.force:
+        mode = "metadata only (bare)" if args.bare else "workspace + metadata"
+        print(f"Duplicate project ({mode}) to workset:")
+        print(f"  from:    {source_path}")
+        print(f"  workset: {ws_name}/{proj_name}")
+        print()
+        try:
+            confirm_prompt("Type 'yes' to confirm: ")
+        except Exception:
+            print("Aborted.")
+            return 2
+
+    # Re-root the project into the workset group (copy workspace unless --bare).
+    _copy_into_workset(ws, proj_name, src_proj, source_path, source_mode, copy_workspace=not args.bare)
+
+    print("Duplicated project to workset:")
+    print(f"  from:    {source_path}")
+    print(f"  workset: {ws_name}/{proj_name}")
+    return 0
+
+
+def _duplicate_from_workset(args, source_path, new_path, std, config) -> int:
+    """Duplicate a workset project to default-mode or standalone layout (source untouched)."""
+    to_mode_str = args.to_mode
+
+    ws, proj_name = _find_workset_for_path(source_path, std)
+    if proj_name is None:
+        print("Error: not inside a specific project workspace.", file=sys.stderr)
+        return 1
+    src_proj = resolve_workset_project(
+        WorksetSpec.from_workset(ws), proj_name, std, config, initialize=False,
+    )
+
+    if not src_proj.metadata_path.is_dir():
+        print(f"Error: no project data found for source path: {source_path}", file=sys.stderr)
+        return 1
+
+    target_mode = ProjectMode.standalone if to_mode_str == "standalone" else ProjectMode.default
+
+    # Lock file warning.
+    lock_file = src_proj.metadata_path / ".kanibako.lock"
+    if lock_file.exists():
+        print(
+            "Warning: lock file found — a container may be running for this project.",
+            file=sys.stderr,
+        )
+        if not args.force:
+            print("Aborted.")
+            return 2
+
+    if not args.force:
+        mode = "metadata only (bare)" if args.bare else "workspace + metadata"
+        print(f"Duplicate workset project ({mode}) to {target_mode.value} mode:")
+        print(f"  from: {ws.name}/{proj_name}")
+        print(f"    to: {new_path}")
+        print()
+        try:
+            confirm_prompt("Type 'yes' to confirm: ")
+        except Exception:
+            print("Aborted.")
+            return 2
+
+    # Copy workspace (unless --bare).
+    if not args.bare:
+        ws_workspace = ws.workspaces_dir / proj_name
+        if ws_workspace.is_dir():
+            shutil.copytree(ws_workspace, new_path, dirs_exist_ok=args.force)
+
+    # Copy metadata into target layout.
+    # default<->standalone: architectural boundary (centralized vs in-workspace metadata), not re-rooting — kept distinct (#71 B2).
+    if target_mode == ProjectMode.standalone:
+        _duplicate_to_standalone(src_proj, new_path, args.force)
+    else:
+        _duplicate_to_local(src_proj, new_path, std, config, args.force)
+
+    print(f"Duplicated project to {target_mode.value} mode:")
+    print(f"  from: {ws.name}/{proj_name}")
+    print(f"    to: {new_path}")
+    return 0
+
+
+def run_duplicate(args: argparse.Namespace) -> int:
+    config_file = config_file_path(xdg("XDG_CONFIG_HOME", ".config"))
+    config = load_config(config_file)
+    std = load_std_paths(config)
+
+    # Cross-mode duplication.
+    if getattr(args, "to_mode", None) is not None:
+        return _run_duplicate_cross_mode(args, std, config)
+
+    source_path = Path(args.source_path).resolve()
+    new_path = Path(args.new_path).resolve()
+
+    # 1. Paths must differ.
+    if source_path == new_path:
+        print("Error: source and destination paths are the same.", file=sys.stderr)
+        return 1
+
+    # 2. Source must be an existing directory.
+    if not source_path.is_dir():
+        print(f"Error: source path does not exist as a directory: {source_path}", file=sys.stderr)
+        return 1
+
+    # 3. Source must have kanibako metadata.
+    source_name, source_project_dir = _resolve_local_dir(
+        std.data_path, str(source_path), std.boxes,
+    )
+
+    if not source_project_dir.is_dir():
+        print(
+            f"Error: no project data found for source path: {source_path}",
+            file=sys.stderr,
+        )
+        return 1
+
+    # 4. Non-bare: destination workspace must not already exist (unless --force).
+    if not args.bare and new_path.exists() and not args.force:
+        print(
+            f"Error: destination already exists: {new_path}",
+            file=sys.stderr,
+        )
+        print("  Use --force to overwrite.", file=sys.stderr)
+        return 1
+
+    # 5. Destination metadata must not already exist (unless --force).
+    new_name, new_project_dir = _resolve_local_dir(
+        std.data_path, str(new_path), std.boxes,
+    )
+
+    if new_project_dir.is_dir() and not args.force:
+        print(
+            f"Error: project data already exists for destination: {new_path}",
+            file=sys.stderr,
+        )
+        print("  Use --force to overwrite.", file=sys.stderr)
+        return 1
+
+    # 6. Lock file warning.
+    lock_file = source_project_dir / ".kanibako.lock"
+    if lock_file.exists():
+        print(
+            "Warning: lock file found — a container may be running for this project.",
+            file=sys.stderr,
+        )
+        if not args.force:
+            print("Aborted.")
+            return 2
+
+    # 7. User confirmation.
+    if not args.force:
+        mode = "metadata only (bare)" if args.bare else "workspace + metadata"
+        print(f"Duplicate project ({mode}):")
+        print(f"  from: {source_path}")
+        print(f"    to: {new_path}")
+        print()
+        try:
+            confirm_prompt("Type 'yes' to confirm: ")
+        except Exception:
+            print("Aborted.")
+            return 2
+
+    # Copy workspace (unless --bare).
+    if not args.bare:
+        shutil.copytree(source_path, new_path, dirs_exist_ok=args.force)
+
+    # Assign a new name for the duplicate.
+    dup_name = assign_name(std.data_path, str(new_path))
+    new_project_dir = std.boxes / dup_name
+
+    # Copy metadata (entire project dir including home/).
+    if args.force and new_project_dir.is_dir():
+        shutil.rmtree(new_project_dir)
+    shutil.copytree(
+        source_project_dir, new_project_dir,
+        ignore=shutil.ignore_patterns(".kanibako.lock"),
+    )
+
+    print("Duplicated project:")
+    print(f"  from: {source_path} ({source_name})")
+    print(f"    to: {new_path} ({dup_name})")
+    return 0