campfire-cli 0.1.0__py3-none-any.whl

campfire_cli/app/document/service/frontmatter_formatter.py

@@ -0,0 +1,104 @@
+"""
+SPEC:
+  name: frontmatter_formatter
+  purpose: 按文档有效 Profile 的字段顺序格式化 Vault frontmatter
+  default_env_file: none
+  env_override: none
+  idempotent: true
+  behavior:
+    - check 模式只读报告字段顺序异常
+    - apply 模式只重排顶级字段块并保留字段值、注释和正文
+    - 不属于 Profile 的字段按原相对顺序保留在标准字段之后并交由 Validator 报告
+  safety:
+    - 不新增、删除或修改字段值
+    - frontmatter 缺失、未闭合或存在重复顶级字段时不修改
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from campfire_cli.app.document.service.document_scanner import iter_documents
+from campfire_cli.app.document.service.profile_registry import ProfileRegistry
+from campfire_cli.common.documents.document_types import frontmatter_bounds
+from campfire_cli.common.documents.frontmatter_schema import KEY_RE, parse_shape
+
+
+def split_blocks(text: str) -> tuple[list[str], list[tuple[str, list[str]]], list[str]]:
+    bounds = frontmatter_bounds(text)
+    if not bounds:
+        raise ValueError("frontmatter missing or unclosed")
+    lines = text[bounds[0] : bounds[1]].splitlines()
+    preamble: list[str] = []
+    blocks: list[tuple[str, list[str]]] = []
+    current_key: str | None = None
+    current_lines: list[str] = []
+    for line in lines:
+        match = KEY_RE.match(line)
+        if match:
+            if current_key is not None:
+                blocks.append((current_key, current_lines))
+            current_key = match.group(1)
+            current_lines = [line]
+        elif current_key is None:
+            preamble.append(line)
+        else:
+            current_lines.append(line)
+    if current_key is not None:
+        blocks.append((current_key, current_lines))
+    return preamble, blocks, lines
+
+
+def ordered_keys(blocks: list[tuple[str, list[str]]], field_order: list[str]) -> list[str]:
+    keys = [key for key, _ in blocks]
+    known = [key for key in field_order if key in keys]
+    unknown = [key for key in keys if key not in field_order]
+    return known + unknown
+
+
+def format_text(text: str, field_order: list[str]) -> tuple[str, list[str]]:
+    bounds = frontmatter_bounds(text)
+    if not bounds:
+        return text, ["frontmatter-missing-or-unclosed"]
+    preamble, blocks, _ = split_blocks(text)
+    keys = [key for key, _ in blocks]
+    if len(keys) != len(set(keys)):
+        return text, ["frontmatter-duplicate-key"]
+    by_key = {key: lines for key, lines in blocks}
+    sorted_keys = ordered_keys(blocks, field_order)
+    rendered_lines = [*preamble]
+    for key in sorted_keys:
+        rendered_lines.extend(by_key[key])
+    rendered = "---\n" + "\n".join(rendered_lines) + text[bounds[1] :]
+    return rendered, []
+
+
+def build_result(
+    root: Path, type_config: dict[str, Any], schema: dict[str, Any], apply: bool
+) -> dict[str, Any]:
+    root = root.resolve()
+    profiles = ProfileRegistry(type_config, schema)
+    issues: list[dict[str, str]] = []
+    changed: list[str] = []
+    documents = iter_documents(root, type_config)
+    for path in documents:
+        original = path.read_text(encoding="utf-8")
+        values, _ = parse_shape(original)
+        profile = profiles.resolve(values.get("type"), values, path)
+        formatted, errors = format_text(original, list(profile.field_order))
+        rel = str(path.relative_to(root))
+        for error in errors:
+            issues.append({"code": error, "path": rel})
+        if not errors and formatted != original:
+            changed.append(rel)
+            if apply:
+                path.write_text(formatted, encoding="utf-8")
+    return {
+        "status": "issues-found" if issues else ("applied" if apply else "ok"),
+        "mode": "apply" if apply else "check",
+        "document_count": len(documents),
+        "reorder_count": len(changed),
+        "reordered": changed,
+        "issues": issues,
+    }

campfire_cli/app/document/service/frontmatter_plan.py

@@ -0,0 +1,75 @@
+"""
+SPEC:
+  name: frontmatter_plan
+  purpose: 生成分层 frontmatter 缺失字段的可审阅补全计划
+  default_env_file: none
+  env_override: none
+  idempotent: true
+  behavior:
+    - 从一级标题确定性建议 name
+    - 对列表字段建议空列表，其余语义字段保留 null
+    - 每个字段默认 approved false
+  safety:
+    - 不修改文档，不编造摘要、日期、状态或业务事实
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+from campfire_cli.app.document.service.document_scanner import iter_documents
+from campfire_cli.app.document.service.profile_registry import ProfileRegistry
+from campfire_cli.common.documents.frontmatter_schema import parse_shape
+
+
+def title(text: str) -> str | None:
+    body = text
+    if text.startswith("---\n"):
+        end = text.find("\n---\n", 4)
+        if end >= 0:
+            body = text[end + 5 :]
+    match = re.search(r"^#\s+(.+?)\s*$", body, re.MULTILINE)
+    return match.group(1).strip() if match else None
+
+
+def build_plan(root: Path, type_config: dict[str, Any], schema: dict[str, Any]) -> dict[str, Any]:
+    root = root.resolve()
+    profiles = ProfileRegistry(type_config, schema)
+    items = []
+    for path in iter_documents(root, type_config):
+        text = path.read_text(encoding="utf-8")
+        values, kinds = parse_shape(text)
+        profile = profiles.resolve(values.get("type"), values, path)
+        fields = {}
+        conditional = set(profile.conditional_fields(values))
+        for field in profile.required_for(values):
+            if field in values and (values[field] or kinds.get(field) == "list"):
+                continue
+            value: Any = None
+            confidence = "low"
+            reason = "semantic-input-required"
+            if field == "name" and title(text):
+                value = title(text)
+                confidence = "high"
+                reason = "first-heading"
+            elif field in profile.lists and field not in conditional:
+                value = []
+                confidence = "high"
+                reason = "empty-list-default"
+            fields[field] = {
+                "value": value,
+                "confidence": confidence,
+                "reason": reason,
+                "approved": False,
+            }
+        if fields:
+            items.append(
+                {
+                    "path": str(path.relative_to(root)),
+                    "profile": profile.name,
+                    "fields": fields,
+                }
+            )
+    return {"version": 1, "schema_version": schema.get("version", 1), "items": items}

campfire_cli/app/document/service/profile_registry.py

@@ -0,0 +1,166 @@
+"""Compile declarative document Profile contracts into effective rules."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from campfire_cli.common.documents.frontmatter_schema import is_project_context
+from campfire_cli.common.exceptions import ConfigurationError
+
+
+def ordered_union(*values: list[str] | tuple[str, ...]) -> tuple[str, ...]:
+    return tuple(dict.fromkeys(item for group in values for item in group))
+
+
+@dataclass(frozen=True)
+class EffectiveProfile:
+    name: str
+    field_order: tuple[str, ...]
+    required: tuple[str, ...]
+    optional: tuple[str, ...]
+    enums: dict[str, tuple[str, ...]]
+    lists: tuple[str, ...]
+    dates: tuple[str, ...]
+    conditional_required: tuple[dict[str, Any], ...]
+    unknown_fields: str
+
+    @property
+    def allowed(self) -> tuple[str, ...]:
+        return ordered_union(self.required, self.optional)
+
+    def conditional_fields(self, values: dict[str, Any]) -> tuple[str, ...]:
+        return ordered_union(
+            *[
+                condition["require"]
+                for condition in self.conditional_required
+                if all(values.get(key) == value for key, value in condition["when"].items())
+            ]
+        )
+
+    def required_for(self, values: dict[str, Any]) -> tuple[str, ...]:
+        return ordered_union(self.required, self.conditional_fields(values))
+
+    def model_dump(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "field_order": list(self.field_order),
+            "required": list(self.required),
+            "optional": list(self.optional),
+            "allowed": list(self.allowed),
+            "enums": {key: list(value) for key, value in self.enums.items()},
+            "lists": list(self.lists),
+            "dates": list(self.dates),
+            "conditional_required": list(self.conditional_required),
+            "unknown_fields": self.unknown_fields,
+        }
+
+
+class ProfileRegistry:
+    """Compile declarative profile inheritance into immutable effective profiles."""
+
+    def __init__(self, type_config: dict[str, Any], schema: dict[str, Any]) -> None:
+        if schema.get("version") != 2:
+            raise ConfigurationError("Frontmatter Schema 必须是 version 2")
+        self._type_config = type_config
+        self._schema = schema
+        raw_profiles = schema.get("profiles", {})
+        if "base" not in raw_profiles:
+            raise ConfigurationError("Frontmatter Schema 缺少 base Profile")
+        self._profiles = {name: self._compile(name, raw_profiles) for name in raw_profiles}
+        self._validate_resolver()
+
+    def list(self) -> list[EffectiveProfile]:
+        return list(self._profiles.values())
+
+    def get(self, name: str) -> EffectiveProfile:
+        try:
+            return self._profiles[name]
+        except KeyError as exc:
+            raise ConfigurationError(f"未知 Frontmatter Profile：{name}") from exc
+
+    def resolve(
+        self, document_type: Any, frontmatter: dict[str, Any], path: Path | None = None
+    ) -> EffectiveProfile:
+        resolver = self._schema.get("resolver", {})
+        direct = (
+            resolver.get("profile_by_type", {}).get(document_type)
+            if isinstance(document_type, str)
+            else None
+        )
+        if direct:
+            return self.get(direct)
+        project_types = set(self._type_config.get("profiles", {}).get("project-docs", []))
+        if (
+            isinstance(document_type, str)
+            and document_type in project_types
+            and (frontmatter.get("project") or is_project_context(path))
+        ):
+            profile = resolver.get("profile_by_governance", {}).get("project-docs")
+            if profile:
+                return self.get(profile)
+        return self.get(resolver.get("fallback", "base"))
+
+    def known_fields(self) -> set[str]:
+        return {field for profile in self._profiles.values() for field in profile.allowed}
+
+    def _compile(self, name: str, raw_profiles: dict[str, dict[str, Any]]) -> EffectiveProfile:
+        raw = raw_profiles[name]
+        parent_name = raw.get("extends")
+        if name == "base" and parent_name:
+            raise ConfigurationError("base Profile 不能继承其他 Profile")
+        if parent_name and parent_name != "base":
+            raise ConfigurationError(f"Profile {name} 只能继承 base")
+        parent = self._compile("base", raw_profiles) if parent_name else None
+        required = ordered_union(parent.required if parent else (), raw.get("required", []))
+        optional = ordered_union(parent.optional if parent else (), raw.get("optional", []))
+        enums = dict(parent.enums) if parent else {}
+        enums.update({key: tuple(value) for key, value in raw.get("enums", {}).items()})
+        lists = ordered_union(parent.lists if parent else (), raw.get("lists", []))
+        dates = ordered_union(parent.dates if parent else (), raw.get("dates", []))
+        conditions = tuple(
+            [*(parent.conditional_required if parent else ()), *raw.get("conditional_required", [])]
+        )
+        order = tuple(raw.get("field_order", parent.field_order if parent else []))
+        unknown_fields = raw.get("unknown_fields", parent.unknown_fields if parent else "preserve")
+        if unknown_fields not in {"preserve", "report"}:
+            raise ConfigurationError(f"Profile {name} unknown_fields 必须是 preserve 或 report")
+        allowed = set(required) | set(optional)
+        constrained = set(enums) | set(lists) | set(dates)
+        condition_fields = {
+            field
+            for condition in conditions
+            for field in [*condition.get("when", {}), *condition.get("require", [])]
+        }
+        invalid_constraints = sorted((constrained | condition_fields) - allowed)
+        if invalid_constraints:
+            raise ConfigurationError(f"Profile {name} 约束了未允许字段：{invalid_constraints}")
+        if set(order) != allowed:
+            missing = sorted(allowed - set(order))
+            extra = sorted(set(order) - allowed)
+            raise ConfigurationError(
+                f"Profile {name} field_order 与允许字段不一致；missing={missing}, extra={extra}"
+            )
+        return EffectiveProfile(
+            name=name,
+            field_order=order,
+            required=required,
+            optional=optional,
+            enums=enums,
+            lists=lists,
+            dates=dates,
+            conditional_required=conditions,
+            unknown_fields=unknown_fields,
+        )
+
+    def _validate_resolver(self) -> None:
+        resolver = self._schema.get("resolver", {})
+        names = {
+            resolver.get("fallback", "base"),
+            *resolver.get("profile_by_type", {}).values(),
+            *resolver.get("profile_by_governance", {}).values(),
+        }
+        unknown = sorted(names - self._profiles.keys())
+        if unknown:
+            raise ConfigurationError(f"Resolver 引用了未知 Profile：{unknown}")

campfire_cli/app/document/service/type_apply.py

@@ -0,0 +1,185 @@
+"""
+SPEC:
+  name: type_apply
+  purpose: 执行已审批的 Vault 文档单选 type 与文件名前缀治理计划
+  default_env_file: none
+  env_override: none
+  idempotent: true
+  behavior:
+    - 仅执行 approved true 的计划项
+    - 补齐单选 type 并在原目录内按契约改名
+    - 更新唯一文件名 wikilink、明确路径 Markdown 链接和 Canvas 文件节点
+  safety:
+    - 执行前完整预检，存在任一阻塞问题时不写入
+    - 不覆盖目标文件，不跨目录移动，不删除文档正文
+    - 不执行缺少 proposed_type 或低置信度未审批项
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any
+from urllib.parse import quote
+
+from campfire_cli.common.documents.document_types import (
+    prefixed_name,
+    safe_path,
+    set_frontmatter_scalar,
+)
+
+WIKILINK_RE = re.compile(r"(!?\[\[)([^\]|#]+)([^\]]*\]\])")
+MARKDOWN_LINK_RE = re.compile(r"(!?\[[^\]]*\]\()([^)]+)(\))")
+
+
+def load_plan(path: Path) -> dict[str, Any]:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def preflight(
+    root: Path, plan: dict[str, Any], config: dict[str, Any]
+) -> tuple[list[dict[str, Any]], list[dict[str, str]]]:
+    approved = [item for item in plan.get("items", []) if item.get("approved") is True]
+    issues: list[dict[str, str]] = []
+    seen_targets: set[Path] = set()
+    operations: list[dict[str, Any]] = []
+    for item in approved:
+        source_name = item.get("source", "")
+        target_name = item.get("target", "")
+        doc_type = item.get("proposed_type")
+        if not source_name or not target_name:
+            issues.append(
+                {
+                    "code": "type-plan-path-missing",
+                    "path": source_name or target_name or "<unknown>",
+                }
+            )
+            continue
+        try:
+            source = safe_path(root, source_name)
+            target = safe_path(root, target_name)
+        except ValueError:
+            issues.append({"code": "type-plan-path-outside-root", "path": source_name})
+            continue
+        if not source.is_file():
+            issues.append({"code": "type-source-missing", "path": source_name})
+        if source.suffix.lower() != ".md" or target.suffix.lower() != ".md":
+            issues.append({"code": "type-plan-not-markdown", "path": source_name})
+        if source.parent != target.parent:
+            issues.append(
+                {"code": "type-plan-cross-directory", "path": source_name, "detail": target_name}
+            )
+        if doc_type not in config["types"]:
+            issues.append(
+                {"code": "type-plan-type-invalid", "path": source_name, "detail": str(doc_type)}
+            )
+        elif target.name != prefixed_name(source.name, doc_type, config):
+            issues.append(
+                {"code": "type-plan-target-invalid", "path": source_name, "detail": target.name}
+            )
+        if target in seen_targets:
+            issues.append({"code": "type-plan-target-duplicate", "path": target_name})
+        seen_targets.add(target)
+        if target.exists() and target != source:
+            issues.append({"code": "type-target-exists", "path": target_name})
+        operations.append({"source": source, "target": target, "type": doc_type})
+    return operations, issues
+
+
+def rewrite_wikilinks(text: str, old_stem: str, new_stem: str) -> str:
+    def replace(match: re.Match[str]) -> str:
+        target = match.group(2)
+        normalized = target.replace("\\", "/")
+        if "/" in normalized:
+            parts = normalized.split("/")
+            if parts[-1] == old_stem:
+                parts[-1] = new_stem
+                target = "/".join(parts)
+        elif normalized == old_stem:
+            target = new_stem
+        return match.group(1) + target + match.group(3)
+
+    return WIKILINK_RE.sub(replace, text)
+
+
+def rewrite_same_directory_markdown_links(
+    text: str, reference: Path, source: Path, target: Path
+) -> str:
+    if reference.parent.resolve() != source.parent.resolve():
+        return text
+    plain = {source.name: target.name, f"./{source.name}": f"./{target.name}"}
+    encoded = {quote(old): quote(new) for old, new in plain.items()}
+    replacements = {**plain, **encoded}
+
+    def replace(match: re.Match[str]) -> str:
+        destination = match.group(2)
+        base, separator, fragment = destination.partition("#")
+        if base not in replacements:
+            return match.group(0)
+        rewritten = replacements[base] + (separator + fragment if separator else "")
+        return match.group(1) + rewritten + match.group(3)
+
+    return MARKDOWN_LINK_RE.sub(replace, text)
+
+
+def reference_files(root: Path) -> list[Path]:
+    ignored = {".git"}
+    return sorted(
+        path
+        for path in root.rglob("*")
+        if path.is_file()
+        and path.suffix.lower() in {".md", ".canvas"}
+        and not any(part in ignored for part in path.relative_to(root).parts)
+    )
+
+
+def apply_plan(root: Path, operations: list[dict[str, Any]]) -> dict[str, Any]:
+    root = root.resolve()
+    original_stem_counts: dict[str, int] = {}
+    for path in root.rglob("*.md"):
+        if ".git" not in path.relative_to(root).parts:
+            original_stem_counts[path.stem] = original_stem_counts.get(path.stem, 0) + 1
+
+    prepared: list[dict[str, Any]] = []
+    for operation in operations:
+        source: Path = operation["source"]
+        updated = set_frontmatter_scalar(
+            source.read_text(encoding="utf-8"), "type", operation["type"]
+        )
+        prepared.append({**operation, "content": updated})
+
+    changed_references: set[str] = set()
+    for operation in prepared:
+        source: Path = operation["source"]
+        target: Path = operation["target"]
+        target.write_text(operation["content"], encoding="utf-8")
+        if target != source:
+            source.unlink()
+
+    for path in reference_files(root):
+        text = path.read_text(encoding="utf-8")
+        updated = text
+        for operation in prepared:
+            source: Path = operation["source"]
+            target: Path = operation["target"]
+            if source == target:
+                continue
+            if original_stem_counts.get(source.stem) == 1:
+                updated = rewrite_wikilinks(updated, source.stem, target.stem)
+            if path.suffix.lower() == ".md":
+                updated = rewrite_same_directory_markdown_links(updated, path, source, target)
+            source_rel = str(source.relative_to(root)).replace("\\", "/")
+            target_rel = str(target.relative_to(root)).replace("\\", "/")
+            updated = updated.replace(source_rel, target_rel).replace(
+                quote(source_rel), quote(target_rel)
+            )
+        if updated != text:
+            path.write_text(updated, encoding="utf-8")
+            changed_references.add(str(path.relative_to(root)))
+    return {
+        "applied_count": len(prepared),
+        "renamed_count": sum(item["source"] != item["target"] for item in prepared),
+        "reference_file_count": len(changed_references),
+        "changed_reference_files": sorted(changed_references),
+    }

campfire_cli/app/document/service/type_plan.py

@@ -0,0 +1,80 @@
+"""
+SPEC:
+  name: type_plan
+  purpose: 为 Vault 文档生成可审阅的 type 与文件名前缀治理计划
+  default_env_file: none
+  env_override: none
+  idempotent: true
+  behavior:
+    - 已有合法单选 type 时生成高置信度改名建议
+    - 只有合法文件名前缀时生成高置信度 type 补全建议
+    - 无法确定时保留待 Agent 或人类审批项
+  safety:
+    - 不修改任何文档
+    - 所有计划项默认 approved false
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from campfire_cli.app.document.service.document_scanner import iter_documents
+from campfire_cli.common.documents.document_types import (
+    frontmatter_value,
+    prefix_type,
+    prefixed_name,
+)
+
+
+def contextual_suggestion(path: Path) -> tuple[str | None, str]:
+    value = str(path).lower()
+    rules = [
+        (("工作周报", "weekly"), "weekly-report"),
+        (("会议记录", "会议纪要"), "meeting"),
+        (("工作日志",), "work-log"),
+        (("开发实验",), "experiment"),
+        (("提示词", "prompt"), "prompt"),
+    ]
+    for needles, doc_type in rules:
+        if any(needle.lower() in value for needle in needles):
+            return doc_type, "path-context"
+    return None, "semantic-review-required"
+
+
+def plan_item(root: Path, path: Path, config: dict[str, Any]) -> dict[str, Any] | None:
+    text = path.read_text(encoding="utf-8")
+    doc_type, multiple = frontmatter_value(text, "type")
+    by_prefix = prefix_type(path.name, config)
+    proposed: str | None = None
+    confidence = "low"
+    reason = "semantic-review-required"
+    if not multiple and doc_type in config["types"]:
+        proposed, confidence, reason = doc_type, "high", "existing-valid-type"
+    elif not multiple and not doc_type and by_prefix:
+        proposed, confidence, reason = by_prefix, "high", "existing-unique-prefix"
+    elif not multiple and (not doc_type or doc_type not in config["types"]):
+        proposed, reason = contextual_suggestion(path)
+        confidence = "medium" if proposed else "low"
+    target_name = prefixed_name(path.name, proposed, config) if proposed else path.name
+    if proposed is not None and proposed == doc_type and target_name == path.name and not multiple:
+        return None
+    rel = path.relative_to(root).as_posix()
+    target = path.with_name(target_name).relative_to(root).as_posix()
+    return {
+        "source": rel,
+        "target": target,
+        "current_type": doc_type,
+        "proposed_type": proposed,
+        "confidence": confidence,
+        "reason": "type-is-sequence" if multiple else reason,
+        "approved": False,
+    }
+
+
+def build_plan(root: Path, config: dict[str, Any]) -> dict[str, Any]:
+    root = root.resolve()
+    items = [
+        item for path in iter_documents(root, config) if (item := plan_item(root, path, config))
+    ]
+    return {"version": 1, "contract_version": config.get("version", 1), "items": items}

campfire_cli/app/maintenance/SPEC.md

@@ -0,0 +1,22 @@
+# Maintenance App SPEC
+
+本模块处理后续增量维护、链接检查、MOC 等自动生成物、两阶段归档和状态索引。Space/Domain 结构由 Workspace App 提供，本模块不重复定义。语义计划使用稳定 ID，默认未审批，写操作必须显式确认；不维护含义不明的 `current-plan`。
+
+文档扫描、类型、Profile、任务状态、模板枚举、Frontmatter 顺序和跨字段不变量均委托 Document App；本模块只负责 Workspace 范围的扫描编排、过滤、统一计划、执行、局部验收、派生内容和报告。写入在治理锁内复核内容哈希和治理配置哈希。
+
+受管范围由当前 Workspace 中实际存在的 `_空间.md` 动态发现，不使用固定 Space 白名单；`scope_roots` 只补充收件箱等非 Space 系统范围。声明文件由 Workspace App 校验，不计入普通文档问题。
+
+`maintenance plan --spec` 是 Agent 语义判断进入确定性执行链路的唯一批量入口。Plan 可以修改 Frontmatter、按有效 type 在同一 Domain 内修正文件名并格式化字段顺序；不得跨目录移动。跨 Domain 迁移属于 Workspace Restructure。
+
+`maintenance verify` 只检查指定 Plan 涉及的文档，不被其他范围的历史问题影响。`check --scope` 的 status 表示当前筛选结果，`workspace_status` 表示全 Workspace 状态。`sync --scope` 只受当前范围的结构问题阻塞。
+
+```text
+maintenance/
+├── link_service.py
+├── moc_service.py
+├── archive_service.py
+├── plan_service.py
+└── maintenance_service.py
+```
+
+归档是 Maintenance 子用例，对外使用 `campfire maintenance archive check/apply`，不建立独立 Archive App。

campfire_cli/app/maintenance/__init__.py

@@ -0,0 +1 @@
+"""Incremental Vault maintenance domain."""