campfire-cli 0.1.18__tar.gz → 0.1.20__tar.gz

{campfire_cli-0.1.18 → campfire_cli-0.1.20}/.github/workflows/release.yml

@@ -1,6 +1,7 @@
 name: release
 
 on:
+  workflow_dispatch:
   push:
     tags: ["v*"]
 
@@ -36,6 +37,7 @@ jobs:
           if-no-files-found: error
 
   publish:
+    if: github.event_name == 'push'
     needs: quality
     runs-on: ubuntu-latest
     permissions:

{campfire_cli-0.1.18 → campfire_cli-0.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: campfire-cli
-Version: 0.1.18
+Version: 0.1.20
 Summary: Local-first shared context and governance CLI for humans and agents
 License-Expression: MIT
 License-File: LICENSE
@@ -150,6 +150,8 @@ campfire workspace restructure verify --batch move-001
 
 仓库 Skill 编写规范见 `src/campfire_cli/resources/skills/SPEC.md`。本地与 CI 共用 `uv run python scripts/quality_check.py`；发布前使用 `--release` 增加构建、wheel 隔离安装与冒烟验证。测试日志包含最慢 10 项耗时。Release 的公共 PyPI 安装验证最多等待 3 分钟、间隔 15 秒重试，不重试上传；安装后版本不符直接失败。
 
+发布准备先执行 `uv run python scripts/release_check.py --tag <目标标签>`（默认检查 HEAD，可用 `--target <提交>` 指定）。这是只读检查，不创建或推送标签。远端标签不存在时按正常流程创建；已有标签一致时复用；对象不同或提交不同时停止核对，不强推、不重建。远端已有而本地缺失时先获取原标签再检查。IDE 拉取时的标签冲突不等于源码合并冲突，也不代表分支拉取已完成；不要全局开启“始终替换本地标记”。检查通过不替代质量门禁或用户发布授权。
+
 ## 许可
 
 MIT。

{campfire_cli-0.1.18 → campfire_cli-0.1.20}/README.md

@@ -134,6 +134,8 @@ campfire workspace restructure verify --batch move-001
 
 仓库 Skill 编写规范见 `src/campfire_cli/resources/skills/SPEC.md`。本地与 CI 共用 `uv run python scripts/quality_check.py`；发布前使用 `--release` 增加构建、wheel 隔离安装与冒烟验证。测试日志包含最慢 10 项耗时。Release 的公共 PyPI 安装验证最多等待 3 分钟、间隔 15 秒重试，不重试上传；安装后版本不符直接失败。
 
+发布准备先执行 `uv run python scripts/release_check.py --tag <目标标签>`（默认检查 HEAD，可用 `--target <提交>` 指定）。这是只读检查，不创建或推送标签。远端标签不存在时按正常流程创建；已有标签一致时复用；对象不同或提交不同时停止核对，不强推、不重建。远端已有而本地缺失时先获取原标签再检查。IDE 拉取时的标签冲突不等于源码合并冲突，也不代表分支拉取已完成；不要全局开启“始终替换本地标记”。检查通过不替代质量门禁或用户发布授权。
+
 ## 许可
 
 MIT。

{campfire_cli-0.1.18 → campfire_cli-0.1.20}/SPEC.md

@@ -81,6 +81,7 @@ Campfire 使用语义化版本：
 ```
 
 - 已发布版本不可原地修改；同一版本号必须对应唯一、可重复构建的代码和资源。
+- 已公开标签对象不可变。发布准备必须执行 `scripts/release_check.py --tag <tag>` 对比本地、远端对象及目标提交；对象或提交不一致即停止，禁止重建、强推或自动覆盖本地标签。发布重试复用原标签，不以提交相同为理由替换附注对象。
 - 只修复既有行为时增加补丁版本，例如 `0.17.0 -> 0.17.1`。
 - 新增 CLI 能力、改变治理契约或增加可选公共字段时增加次版本，例如 `0.17.x -> 0.18.0`。
 - 删除或重命名公共命令、改变不可兼容的数据格式时增加主版本；`0.x` 阶段仍应显式记录破坏性变化。
@@ -103,6 +104,7 @@ Campfire 使用语义化版本：
 
 - `domain_id`、`name` 和 `path` 分别表示稳定身份、显示名称和物理位置，不得隐式绑定。
 - 普通 rename 和 move 不得改变 `domain_id`；只有显式 `domain rekey` 可以修改稳定身份。
+- rename 的 `--name` 与 `--folder-name` 分别修改显示名称与原父级内目录名；只有显式传入才修改。目录改名确认带回 `expected_plan`，复用共享文件变更集摘要与补偿机制；不解析正文或 Canvas，不承诺崩溃原子性。
 - 修改领域名称不得修改 Project 名称；Project 展示名称只能由 `workspace project update --name` 显式修改。
 - `.campfire.yaml` 的 `projects[].document_domain_id` 是 Project 到根 Domain 绑定的唯一事实；Domain 声明不保存 Project 字段。
 - Space/Domain 声明 Frontmatter 和 `AUTO-GENERATED` 标记区域由 CLI 管理；标记外 Markdown 正文允许人和 Agent 直接编辑，formatter 必须完整保留。
@@ -114,12 +116,15 @@ Campfire 使用语义化版本：
 
 ## Workspace 索引
 
+- Markdown Frontmatter 的 `related_docs` 是文档关系唯一 SSOT，采用 `[[Workspace相对路径.md]]`。不解析、索引或自动改写正文链接；历史正文保留，SQLite 和可见关系页均可从该字段重建。
+- 改名、移动与类型联动改名只定向更新 `related_docs` 引用方；预览输出 `expected_plan`，确认复核整个变更集摘要和文件哈希。文件提交后的索引失败必须报告已写入事实，并使索引可在下次查询恢复。
+
 - SQLite `spaces`、`domains`、`documents` 只允许作为可重建本机投影，不得反向覆盖 Markdown SSOT。
 - Document App 拥有文档记录、确定关系、集合查询和单篇关系查询；Repository 只持久化投影，不解释 Profile、Domain 或链接语义。
 - 文档索引保存 schema version、parser version、有效配置 hash、拓扑 hash 和 generation；Domain 声明、Project 文档根映射等任一解释输入变化都必须自动完整重建。
 - `document list` 与 `document inspect` 查询前必须轻量 reconcile。文件 stat 只筛选变化候选，content hash 表示内容版本；调用方不需要先运行 Maintenance。
 - 候选文档与关系快照必须在一个 SQLite 事务中切换，失败继续保留上一完整 generation。
-- `document list` 只做结构化精确筛选；`document inspect` 只返回显式关联和链接形成的确定关系。全文检索、模糊匹配、相关性排序和相似建议不得混入这两个契约。
+- `document list` 只做结构化精确筛选；`document inspect` 只返回 `related_docs` 形成的确定关系。全文检索、模糊匹配、相关性排序和相似建议不得混入这两个契约。
 - `setup` 与 `maintenance check` 必须自动刷新完整拓扑和文档索引。
 - 索引 reconcile 是读取命令内部保障，不得作为 follow-up 暴露给 Agent。写命令只在实际写入成功且可见派生状态可能变化时返回零或一个可直接执行的 scoped `maintenance sync` follow-up；Domain 内部路径必须归一化为对应 Domain，预览和阻塞结果必须返回空列表；
   调用方只执行实际返回的 follow-up，不固定追加 check 或全量扫描。

{campfire_cli-0.1.18 → campfire_cli-0.1.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "campfire-cli"
-version = "0.1.18"
+version = "0.1.20"
 description = "Local-first shared context and governance CLI for humans and agents"
 readme = "README.md"
 license = "MIT"

campfire_cli-0.1.20/scripts/release_check.py

@@ -0,0 +1,84 @@
+"""
+SPEC:
+  name: release_check
+  purpose: 发布前只读比较本地与远端标签对象、目标提交，禁止静默替换
+  idempotent: true
+  side_effects: []
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+from pathlib import Path
+
+
+def git(root: Path, *args: str) -> str:
+    return subprocess.run(
+        ["git", *args], cwd=root, check=True, capture_output=True, text=True, timeout=30
+    ).stdout.strip()
+
+
+def check_release(root: Path, tag: str, remote: str = "origin", target: str = "HEAD") -> dict:
+    git(root, "check-ref-format", f"refs/tags/{tag}")
+    commit = git(root, "rev-parse", "--verify", f"{target}^{{commit}}")
+    local_ref = git(root, "for-each-ref", "--format=%(refname)", f"refs/tags/{tag}")
+    local = None
+    if f"refs/tags/{tag}" in local_ref.splitlines():
+        local = {
+            "object": git(root, "rev-parse", f"refs/tags/{tag}"),
+            "commit": git(root, "rev-parse", f"refs/tags/{tag}^{{commit}}"),
+        }
+    refs = {}
+    for line in git(
+        root, "ls-remote", remote, f"refs/tags/{tag}", f"refs/tags/{tag}^{{}}"
+    ).splitlines():
+        oid, ref = line.split()
+        refs[ref] = oid
+    remote_object = refs.get(f"refs/tags/{tag}")
+    remote_tag = (
+        {"object": remote_object, "commit": refs.get(f"refs/tags/{tag}^{{}}", remote_object)}
+        if remote_object
+        else None
+    )
+    code = "tag-ready"
+    action = "reuse" if remote_tag else "push-existing" if local else "create"
+    if any(item and item["commit"] != commit for item in (local, remote_tag)):
+        code, action = "tag-commit-conflict", "stop"
+    elif remote_tag and not local:
+        code, action = "tag-local-missing", "stop"
+    elif remote_tag and local and remote_tag["object"] != local["object"]:
+        code, action = "tag-object-conflict", "stop"
+    return {
+        "status": "blocked" if action == "stop" else "ok",
+        "code": code,
+        "tag": tag,
+        "target_commit": commit,
+        "local": local,
+        "remote": remote_tag,
+        "action": action,
+        "write_performed": False,
+        "hint": "冲突时核对指定标签，不重建或强推；远端已有但本地缺失时先获取原标签。",
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="只读发布标签检查，不创建、推送或覆盖标签")
+    parser.add_argument("--tag", required=True)
+    parser.add_argument("--remote", default="origin")
+    parser.add_argument("--target", default="HEAD")
+    args = parser.parse_args()
+    try:
+        result = check_release(
+            Path(__file__).resolve().parents[1], args.tag, args.remote, args.target
+        )
+    except (subprocess.SubprocessError, OSError, ValueError) as exc:
+        print(json.dumps({"status": "error", "code": "tag-check-failed", "message": str(exc)}))
+        raise SystemExit(1) from exc
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    raise SystemExit(0 if result["status"] == "ok" else 1)
+
+
+if __name__ == "__main__":
+    main()

{campfire_cli-0.1.18 → campfire_cli-0.1.20}/src/campfire_cli/__init__.py

@@ -1,3 +1,3 @@
 """Campfire CLI package."""
 
-__version__ = "0.1.18"
+__version__ = "0.1.20"

{campfire_cli-0.1.18 → campfire_cli-0.1.20}/src/campfire_cli/app/base/service/base_service.py

@@ -18,7 +18,7 @@ class BaseService:
     _FIELD_REFERENCE = re.compile(
         r"(?<![.\w])([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)?)\s*(?:==|!=|\.isEmpty\(|\.contains\()"
     )
-    _ENUM_COMPARISON = re.compile(r'''\b([A-Za-z_]\w*)\s*(?:==|!=)\s*["']([^"']+)["']''')
+    _ENUM_COMPARISON = re.compile(r"""\b([A-Za-z_]\w*)\s*(?:==|!=)\s*["']([^"']+)["']""")
 
     def __init__(self, settings: WorkspaceSettings, repository: BaseRepository) -> None:
         self._settings = settings

{campfire_cli-0.1.18 → campfire_cli-0.1.20}/src/campfire_cli/app/document/SPEC.md

@@ -15,22 +15,11 @@ document/
 ├── schema/
 │   └── document_schema.py
 ├── service/
-│   ├── document_apply_service.py
-│   ├── document_move_service.py
-│   ├── document_profile_service.py
-│   ├── document_type_service.py
-│   ├── document_service.py
-│   ├── document_index_service.py
-│   ├── document_index_builder.py
-│   ├── document_index_protocol.py
-│   ├── document_rule_service.py
-│   ├── document_scanner.py
-│   ├── profile_registry.py
-│   ├── type_plan.py
-│   ├── type_apply.py
-│   ├── frontmatter_plan.py
-│   ├── frontmatter_apply.py
-│   └── frontmatter_formatter.py
+│   ├── document_service.py       # 公开应用入口
+│   ├── document_scanner.py       # 统一受管范围
+│   ├── rules/                    # Profile、字段校验与格式
+│   ├── index/                    # 新鲜度、投影构建与查询
+│   └── mutation/                 # 写入、移动与关系改写
 └── repository/
     ├── document_index_repository.py
     ├── document_profile_repository.py
@@ -38,25 +27,32 @@ document/
 ```
 
 - `profile`：定义并解析不同文档的属性契约。
+- `profile resolve --type` 用于新建前查询，`--path` 用于已有文档，两者互斥；和 apply 共用 ProfileRegistry。`show` 只按 Profile 名查询，不把 type 当作同义参数，不新增领域覆盖机制。
 - `type`：检查、规划和执行单选类型与文件命名治理。
 - `frontmatter`：检查、规划、执行和格式化文档属性。
 - `rule`：统一解释类型、Profile、枚举与跨字段不变量。
-- `index`：Service 只编排新鲜度、generation 和查询，Builder 只把 Markdown、Domain/Project 上下文与显式链接转换为确定性投影；配置、拓扑或解析器变化时完整重建，普通文件变化时调用时 reconcile。
+- `index`：Service 只编排新鲜度、generation 和查询，Builder 只把 Markdown 属性、Domain/Project 上下文与 `related_docs`转换为确定性投影；配置、拓扑或解析器变化时完整重建，普通文件变化时调用时 reconcile。
 - `list`：按 Project、Domain、类型和生命周期对索引做精确 AND 筛选；返回全部生命周期，不读取或复制正文。
-- `inspect`：向 Agent 返回单篇文档的 Domain、类型、有效 Profile、具体问题，以及 declared、outgoing、incoming、unresolved 四类确定关系。
+- `inspect`：向 Agent 返回单篇文档的 Domain、类型、有效 Profile、具体问题，以及 outgoing、incoming、unresolved 及入度、出度。
 - `apply`：根据目标路径和类型解析 Profile，不存在时生成文档，已有 Frontmatter 时只应用显式补丁，无 Frontmatter 时保留正文并补齐完整契约；先完整渲染并校验，追加 `--confirm` 后原子写入。
 - `template`：只继承 base Profile，必须位于所属 Domain 的 `_模板/`；Domain 归属由物理路径解析，不在 Frontmatter 复制模板作用域或继承关系。
-- `move`：在任意已声明 Domain 之间移动一篇文档，按目标 Profile 对齐可确定的 `domain`/`project` 归属，并更新可确定解析的 Wiki、Markdown 和路径引用。目标 Profile 缺少业务字段时返回 `needs-input`，不猜测。
+- `move`：在任意已声明 Domain 之间移动一篇文档，按目标 Profile 对齐可确定的 `domain`/`project` 归属，并只更新 `related_docs` 的精确路径引用。目标 Profile 缺少业务字段时返回 `needs-input`，不猜测。
 - `rename`：保持一篇文档的物理目录与 Domain 归属不变，根据逻辑标题重算类型前缀文件名，并在同一变更集中更新 `name` 与可确定引用。目标存在时阻止，不覆盖或自动编号。
 - `scanner`：统一解释受管根、忽略目录和豁免文件；Document 与 Maintenance 共用。
 
 Document Service 可以被 Workspace Restructure 编排，但不得反向依赖 Maintenance。批量计划文件、运行记录、MOC、Base、归档和重构批次不属于 Document App。
 
-Markdown 是内容与关系事实源，SQLite 是按 Workspace 隔离的查询投影。Document Index Repository 不解析 Markdown、Profile 或 Domain，只原子持久化文档、关系和 generation 快照。索引不得复制正文；相似度、全文关键词和相关性排序不属于当前契约，未来只能以独立 suggestions/search 契约扩展。
+Markdown 是内容事实源，Frontmatter `related_docs` 是文档关系唯一 SSOT，SQLite 是按 Workspace 隔离的查询投影。Document Index Repository 不解析 Markdown、Profile 或 Domain，只原子持久化文档、关系和 generation 快照。索引不得复制正文；相似度、全文关键词和相关性排序不属于当前契约，未来只能以独立 suggestions/search 契约扩展。
 
 `list` 与 `inspect` 自行保障查询新鲜度，不返回索引维护 follow-up。文件 size/mtime 只用于发现变化候选，content hash 表示内容版本；Space/Domain 声明、Project 根 Domain 映射或有效治理配置变化必须触发完整重建。Project 归属只从 Manifest 的稳定根 Domain id 与 Domain 祖先拓扑解析，不读取 Domain 声明或文档 Frontmatter 中的重复值。MOC 与其他生成文档不作为普通内容节点。
 
-`apply` 与 `move` 只保证目标文档操作自身有效，不触发 Maintenance。结果只在派生状态可能变化时返回一个最小 scope 的 `maintenance sync`；调用方不得固定追加 check。所有写入先生成完整 ChangeSet，再经共享 Executor 在乐观锁内提交；多文件操作失败时恢复提交前内容。
+`related_docs` 可选，省略或空数组均表示无出向关联。每项为完整 Workspace 相对 POSIX Wiki 路径并保留 `.md`；拒绝别名、锚点、越界、无效目标、自引用和重复项。目标删除保留 unresolved 路径，恢复后重新解析；来源删除移除出向边。正文链接、Canvas 和相似度不参与此协议。
+
+索引增量提交只更新变化文档与对应来源边；目标可用性变化只更新受影响目标边。查询在 SQL 层筛选，反向查询按 target 索引，索引 generation 通过事务复核，避免旧快照覆盖新投影。
+
+改路径的确认必须带预览返回的 `expected_plan`，摘要覆盖来源、目标和全部引用方的预期哈希与写入内容。可捕获文件异常回滚；文件成功但索引失败返回 write_performed 与修复提示，dirty 索引在后续读取重建。不承诺跨文件写入具备断电原子性。
+
+`apply` 与 `move` 保证目标及受影响的字段引用在同一文件变更集提交，不触发 Maintenance。结果只在派生状态可能变化时返回一个最小 scope 的 `maintenance sync`；调用方不得固定追加 check。所有写入先生成完整 ChangeSet，再经共享 Executor 在乐观锁内提交；多文件操作失败时恢复提交前内容。
 
 包内 `config.yml` 的默认 Profile 与用户级 `~/.campfire/config.yml` 覆盖共同构成当前治理契约。
 

{campfire_cli-0.1.18 → campfire_cli-0.1.20}/src/campfire_cli/app/document/cli/document_cli.py

@@ -126,6 +126,9 @@ def apply_document(
     document_type: str | None = typer.Option(None, "--type"),
     set_values: list[str] | None = typer.Option(None, "--set", help=SET_OPTION_HELP),
     expected_hash: str | None = typer.Option(None, "--expected-hash"),
+    expected_plan: str | None = typer.Option(
+        None, "--expected-plan", help="改名或移动时传入预览返回的计划摘要"
+    ),
     confirm: bool = typer.Option(False, "--confirm"),
 ) -> None:
     """预览或应用一篇 Profile 合法文档的创建、补丁与显式类型变更。
@@ -145,6 +148,7 @@ def apply_document(
                     document_type=document_type,
                     values=values,
                     expected_hash=expected_hash,
+                    expected_plan=expected_plan,
                     confirm=confirm,
                 )
             )
@@ -161,6 +165,9 @@ def move_document(
     set_values: list[str] | None = typer.Option(None, "--set", help=SET_OPTION_HELP),
     unset_fields: list[str] | None = typer.Option(None, "--unset"),
     expected_hash: str | None = typer.Option(None, "--expected-hash"),
+    expected_plan: str | None = typer.Option(
+        None, "--expected-plan", help="改名或移动时传入预览返回的计划摘要"
+    ),
     confirm: bool = typer.Option(False, "--confirm"),
 ) -> None:
     """预览或移动一篇文档，并按目标 Domain 契约更新归属与引用。"""
@@ -174,6 +181,7 @@ def move_document(
                 values=values,
                 unset_fields=tuple(unset_fields or []),
                 expected_hash=expected_hash,
+                expected_plan=expected_plan,
                 confirm=confirm,
             )
         )
@@ -186,6 +194,9 @@ def rename_document(
     source: str = typer.Option(..., "--path", help=PATH_OPTION_HELP),
     name: str = typer.Option(..., "--name", help="新标题；不含类型前缀和 .md 后缀"),
     expected_hash: str | None = typer.Option(None, "--expected-hash"),
+    expected_plan: str | None = typer.Option(
+        None, "--expected-plan", help="改名或移动时传入预览返回的计划摘要"
+    ),
     confirm: bool = typer.Option(False, "--confirm"),
 ) -> None:
     """预览或原地改名一篇文档，并同步标题、文件名与受管引用。"""
@@ -195,6 +206,7 @@ def rename_document(
                 source,
                 name,
                 expected_hash=expected_hash,
+                expected_plan=expected_plan,
                 confirm=confirm,
             )
         )

{campfire_cli-0.1.18 → campfire_cli-0.1.20}/src/campfire_cli/app/document/cli/profile_cli.py

@@ -7,7 +7,7 @@ import typer
 from campfire_cli.app.document.repository.document_profile_repository import (
     DocumentProfileRepository,
 )
-from campfire_cli.app.document.service.document_profile_service import (
+from campfire_cli.app.document.service.rules.document_profile_service import (
     DocumentProfileService,
 )
 from campfire_cli.app.workspace.repository.workspace_repository import SqliteWorkspaceRepository
@@ -50,6 +50,10 @@ def show_profile(ctx: typer.Context, name: str) -> None:
 
 
 @profile_cli.command("resolve")
-def resolve(ctx: typer.Context, path: str = typer.Option(..., "--path")) -> None:
-    """解析一篇文档最终使用的 Profile。"""
-    emit(invoke(lambda: service(ctx).resolve(path)))
+def resolve(
+    ctx: typer.Context,
+    path: str | None = typer.Option(None, "--path", help="已有文档的 Workspace 相对或绝对路径"),
+    document_type: str | None = typer.Option(None, "--type", help="新建文档类型，与 --path 二选一"),
+) -> None:
+    """按已有文档路径或新建文档类型解析有效 Profile。"""
+    emit(invoke(lambda: service(ctx).resolve(path, document_type)))

{campfire_cli-0.1.18 → campfire_cli-0.1.20}/src/campfire_cli/app/document/cli/type_cli.py

@@ -7,7 +7,7 @@ import typer
 from campfire_cli.app.document.repository.document_type_repository import (
     DocumentTypeRepository,
 )
-from campfire_cli.app.document.service.document_type_service import DocumentTypeService
+from campfire_cli.app.document.service.rules.document_type_service import DocumentTypeService
 from campfire_cli.app.workspace.repository.workspace_repository import SqliteWorkspaceRepository
 from campfire_cli.app.workspace.service.workspace_service import WorkspaceService
 from campfire_cli.common.cli_output import emit, invoke

campfire_cli-0.1.20/src/campfire_cli/app/document/repository/document_index_repository.py

@@ -0,0 +1,265 @@
+"""SQLite persistence for the rebuildable document query projection."""
+
+from __future__ import annotations
+
+import json
+
+from sqlalchemy import delete, func, select, update
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.orm import Session
+
+from campfire_cli.app.document.schema import (
+    DocumentEdgeRecord,
+    DocumentIndexMetadata,
+    DocumentIndexRecord,
+)
+from campfire_cli.common.database.models import Document, DocumentEdge, DocumentIndexState
+from campfire_cli.common.exceptions import AppError, GovernanceBlockedError
+
+
+class SqliteDocumentIndexRepository:
+    def __init__(self, session: Session, workspace_id: str) -> None:
+        self._session = session
+        self._workspace_id = workspace_id
+
+    def load_documents(self, paths: set[str] | None = None) -> list[DocumentIndexRecord]:
+        statement = select(Document).where(Document.workspace_id == self._workspace_id)
+        if paths is not None:
+            statement = statement.where(Document.path.in_(paths))
+        rows = self._session.scalars(statement.order_by(Document.path)).all()
+        return [self._document(row) for row in rows]
+
+    def load_fingerprints(self) -> list[DocumentIndexRecord]:
+        rows = self._session.execute(
+            select(
+                Document.path,
+                Document.content_hash,
+                Document.source_size,
+                Document.source_mtime_ns,
+                Document.queryable,
+            ).where(Document.workspace_id == self._workspace_id)
+        ).mappings()
+        return [DocumentIndexRecord(**row) for row in rows]
+
+    def load_edges(
+        self, *, source: str | None = None, target: str | None = None
+    ) -> list[DocumentEdgeRecord]:
+        statement = select(DocumentEdge).where(DocumentEdge.workspace_id == self._workspace_id)
+        if source is not None:
+            statement = statement.where(DocumentEdge.source_path == source)
+        if target is not None:
+            statement = statement.where(DocumentEdge.target_path == target)
+        rows = self._session.scalars(
+            statement.order_by(DocumentEdge.source_path, DocumentEdge.line, DocumentEdge.raw_target)
+        ).all()
+        return [self._edge(row) for row in rows]
+
+    def load_state(self) -> DocumentIndexMetadata | None:
+        row = self._session.get(DocumentIndexState, self._workspace_id, populate_existing=True)
+        if row is None:
+            return None
+        return DocumentIndexMetadata(
+            schema_version=row.schema_version,
+            parser_version=row.parser_version,
+            config_hash=row.config_hash,
+            topology_hash=row.topology_hash,
+            generation=row.generation,
+            status=row.status,
+            rebuilt_at=row.rebuilt_at,
+            indexed_at=row.indexed_at,
+        )
+
+    def query_documents(
+        self, filters: dict[str, str], limit: int | None = None
+    ) -> tuple[list[DocumentIndexRecord], int]:
+        fields = {
+            "project": Document.project_id,
+            "domain": Document.domain_id,
+            "type": Document.document_type,
+            "document_status": Document.document_status,
+            "task_status": Document.task_status,
+        }
+        statement = select(Document).where(
+            Document.workspace_id == self._workspace_id, Document.queryable.is_(True)
+        )
+        for field, value in filters.items():
+            statement = statement.where(fields[field] == value)
+        total = self._session.scalar(select(func.count()).select_from(statement.subquery())) or 0
+        rows = self._session.scalars(statement.order_by(Document.path).limit(limit)).all()
+        return [self._document(row) for row in rows], total
+
+    def counts(self) -> tuple[int, int]:
+        return tuple(
+            self._session.scalar(
+                select(func.count())
+                .select_from(model)
+                .where(model.workspace_id == self._workspace_id)
+            )
+            or 0
+            for model in (Document, DocumentEdge)
+        )
+
+    def mark_dirty(self) -> None:
+        self._session.execute(
+            update(DocumentIndexState)
+            .where(DocumentIndexState.workspace_id == self._workspace_id)
+            .values(status="dirty")
+        )
+        self._session.commit()
+
+    def apply_delta(
+        self,
+        documents: list[DocumentIndexRecord],
+        edges: list[DocumentEdgeRecord],
+        metadata: DocumentIndexMetadata,
+        deleted: set[str],
+        edge_sources: set[str],
+        affected_targets: dict[str, bool],
+    ) -> None:
+        self.replace_snapshot(
+            documents,
+            edges,
+            metadata,
+            deleted=deleted,
+            edge_sources=edge_sources,
+            affected_targets=affected_targets,
+        )
+
+    def replace_snapshot(
+        self,
+        documents: list[DocumentIndexRecord],
+        edges: list[DocumentEdgeRecord],
+        metadata: DocumentIndexMetadata,
+        *,
+        deleted: set[str] | None = None,
+        edge_sources: set[str] | None = None,
+        affected_targets: dict[str, bool] | None = None,
+    ) -> None:
+        try:
+            if metadata.generation > 1:
+                advanced = self._session.execute(
+                    update(DocumentIndexState)
+                    .where(
+                        DocumentIndexState.workspace_id == self._workspace_id,
+                        DocumentIndexState.generation == metadata.generation - 1,
+                    )
+                    .values(generation=metadata.generation)
+                )
+                if advanced.rowcount != 1:
+                    raise GovernanceBlockedError("索引已被其他操作更新，请重新查询")
+            edge_delete = delete(DocumentEdge).where(
+                DocumentEdge.workspace_id == self._workspace_id
+            )
+            document_delete = delete(Document).where(Document.workspace_id == self._workspace_id)
+            if deleted is not None:
+                edge_delete = edge_delete.where(
+                    DocumentEdge.source_path.in_((edge_sources or set()) | deleted)
+                )
+                document_delete = document_delete.where(
+                    Document.path.in_(deleted | {item.path for item in documents})
+                )
+            self._session.execute(edge_delete)
+            self._session.execute(document_delete)
+            for target, exists in (affected_targets or {}).items():
+                self._session.execute(
+                    update(DocumentEdge)
+                    .where(
+                        DocumentEdge.workspace_id == self._workspace_id,
+                        DocumentEdge.target_path == target,
+                        DocumentEdge.resolution.in_(["resolved", "missing"]),
+                    )
+                    .values(resolution="resolved" if exists else "missing")
+                )
+            self._session.add_all(
+                [
+                    Document(
+                        workspace_id=self._workspace_id,
+                        path=item.path,
+                        content_hash=item.content_hash,
+                        name=item.name,
+                        document_type=item.document_type,
+                        domain_id=item.domain_id,
+                        project_id=item.project_id,
+                        document_status=item.document_status,
+                        lifecycle=item.lifecycle,
+                        task_status=item.task_status,
+                        priority=item.priority,
+                        assignee_json=json.dumps(item.assignee, ensure_ascii=False),
+                        due=item.due,
+                        source_updated=item.source_updated,
+                        source_size=item.source_size,
+                        source_mtime_ns=item.source_mtime_ns,
+                        queryable=item.queryable,
+                        exists=True,
+                    )
+                    for item in documents
+                ]
+            )
+            self._session.add_all(
+                [
+                    DocumentEdge(
+                        workspace_id=self._workspace_id,
+                        source_path=item.source_path,
+                        target_path=item.target_path,
+                        raw_target=item.raw_target,
+                        relation_type=item.relation_type,
+                        resolution=item.resolution,
+                        candidates_json=json.dumps(item.candidates, ensure_ascii=False),
+                        line=item.line,
+                    )
+                    for item in edges
+                ]
+            )
+            row = self._session.get(DocumentIndexState, self._workspace_id)
+            if row is None:
+                row = DocumentIndexState(workspace_id=self._workspace_id)
+                self._session.add(row)
+            row.schema_version = metadata.schema_version
+            row.parser_version = metadata.parser_version
+            row.config_hash = metadata.config_hash
+            row.topology_hash = metadata.topology_hash
+            row.generation = metadata.generation
+            row.status = metadata.status
+            row.rebuilt_at = metadata.rebuilt_at
+            row.indexed_at = metadata.indexed_at
+            self._session.commit()
+        except SQLAlchemyError as exc:
+            self._session.rollback()
+            raise AppError("文档索引提交失败，已回滚", code="document-index-write-failed") from exc
+        except Exception:
+            self._session.rollback()
+            raise
+
+    @staticmethod
+    def _document(row: Document) -> DocumentIndexRecord:
+        return DocumentIndexRecord(
+            path=row.path,
+            content_hash=row.content_hash,
+            name=row.name,
+            document_type=row.document_type,
+            domain_id=row.domain_id,
+            project_id=row.project_id,
+            document_status=row.document_status,
+            lifecycle=row.lifecycle,
+            task_status=row.task_status,
+            priority=row.priority,
+            assignee=json.loads(row.assignee_json or "[]"),
+            due=row.due,
+            source_updated=row.source_updated,
+            source_size=row.source_size or 0,
+            source_mtime_ns=row.source_mtime_ns or 0,
+            queryable=row.queryable,
+            indexed_at=row.indexed_at,
+        )
+
+    @staticmethod
+    def _edge(row: DocumentEdge) -> DocumentEdgeRecord:
+        return DocumentEdgeRecord(
+            source_path=row.source_path,
+            target_path=row.target_path,
+            raw_target=row.raw_target,
+            relation_type=row.relation_type,
+            resolution=row.resolution,
+            candidates=json.loads(row.candidates_json or "[]"),
+            line=row.line,
+        )

{campfire_cli-0.1.18 → campfire_cli-0.1.20}/src/campfire_cli/app/document/schema/document_schema.py

@@ -13,6 +13,7 @@ class DocumentApplyRequest(BaseModel):
     document_type: str | None = None
     values: dict[str, str] = Field(default_factory=dict)
     expected_hash: str | None = None
+    expected_plan: str | None = None
     confirm: bool = False
 
 
@@ -26,6 +27,7 @@ class DocumentApplyResult(BaseModel):
     normalization: list[dict[str, Any]] = Field(default_factory=list)
     profile: str
     expected_hash: str
+    expected_plan: str | None = None
     write_performed: bool = False
     updated_references: list[str] = Field(default_factory=list)
     issues: list[dict[str, Any]] = Field(default_factory=list)
@@ -42,6 +44,7 @@ class DocumentMoveResult(BaseModel):
     source_domain: str | None = None
     target_domain: str | None = None
     profile: str | None = None
+    expected_plan: str | None = None
     write_performed: bool = False
     updated_references: list[str] = Field(default_factory=list)
     frontmatter_changes: dict[str, Any] = Field(default_factory=dict)
@@ -74,14 +77,8 @@ class DocumentEdgeRecord(BaseModel):
     source_path: str
     target_path: str | None = None
     raw_target: str
-    relation_type: Literal[
-        "declared-related",
-        "declared-superseded-by",
-        "wikilink",
-        "markdown-link",
-        "embed",
-    ]
-    resolution: Literal["resolved", "missing", "ambiguous"]
+    relation_type: Literal["related_docs"] = "related_docs"
+    resolution: Literal["resolved", "missing", "invalid", "self"]
     candidates: list[str] = Field(default_factory=list)
     line: int | None = None