campfire-cli 0.1.3__tar.gz → 0.1.4__tar.gz

{campfire_cli-0.1.3 → campfire_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: campfire-cli
-Version: 0.1.3
+Version: 0.1.4
 Summary: Local-first shared context and governance CLI for humans and agents
 License-Expression: MIT
 License-File: LICENSE

{campfire_cli-0.1.3 → campfire_cli-0.1.4}/pyproject.toml

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

{campfire_cli-0.1.3 → campfire_cli-0.1.4}/src/campfire_cli/__init__.py

@@ -1,3 +1,3 @@
 """Campfire CLI package."""
 
-__version__ = "0.1.3"
+__version__ = "0.1.4"

{campfire_cli-0.1.3 → campfire_cli-0.1.4}/src/campfire_cli/app/maintenance/service/moc_service.py

@@ -35,18 +35,8 @@ LATIN_RE = re.compile(r"[A-Za-z][A-Za-z0-9.+#_-]{1,}")
 CHINESE_RE = re.compile(r"[\u4e00-\u9fff]{2,}")
 
 
-def note_title(path: Path) -> str:
-    text = path.read_text(encoding="utf-8")
-    match = re.search(r"^#\s+(.+)$", text, re.MULTILINE)
-    return match.group(1).strip() if match else path.stem
-
-
-def note_terms(path: Path) -> Counter[str]:
-    text = path.read_text(encoding="utf-8")
-    terms: list[str] = [token.lower() for token in LATIN_RE.findall(text)]
-    for block in CHINESE_RE.findall(text):
-        terms.extend(block[index : index + 2] for index in range(len(block) - 1))
-    ignored = {
+IGNORED_TERMS = frozenset(
+    {
         "text",
         "true",
         "false",
@@ -73,7 +63,31 @@ def note_terms(path: Path) -> Counter[str]:
         "因为",
         "所以",
     }
-    return Counter(term for term in terms if term not in ignored)
+)
+
+IGNORED_TITLE_KEYWORDS = frozenset(
+    {"go", "agent", "development", "document", "guide", "note", "over", "and", "with"}
+)
+
+
+def note_title(path: Path) -> str:
+    return title_from_text(path.read_text(encoding="utf-8"), path.stem)
+
+
+def title_from_text(text: str, fallback: str) -> str:
+    match = re.search(r"^#\s+(.+)$", text, re.MULTILINE)
+    return match.group(1).strip() if match else fallback
+
+
+def note_terms(path: Path) -> Counter[str]:
+    return terms_from_text(path.read_text(encoding="utf-8"))
+
+
+def terms_from_text(text: str) -> Counter[str]:
+    terms: list[str] = [token.lower() for token in LATIN_RE.findall(text)]
+    for block in CHINESE_RE.findall(text):
+        terms.extend(block[index : index + 2] for index in range(len(block) - 1))
+    return Counter(term for term in terms if term not in IGNORED_TERMS)
 
 
 def similarity(left: Counter[str], right: Counter[str]) -> tuple[float, list[str]]:
@@ -83,22 +97,25 @@ def similarity(left: Counter[str], right: Counter[str]) -> tuple[float, list[str
     if not union:
         return 0.0, []
     common = left_terms & right_terms
-    score = len(common) / len(union)
-    reasons = [
+    return len(common) / len(union), top_reasons(left, right, common)
+
+
+def top_reasons(left: Counter[str], right: Counter[str], common: set[str]) -> list[str]:
+    return [
         term
         for term, _ in sorted(
             ((term, left[term] + right[term]) for term in common),
             key=lambda item: (-item[1], item[0]),
         )[:5]
     ]
-    return score, reasons
 
 
 def title_keywords(path: Path) -> set[str]:
-    title = f"{path.stem} {note_title(path)}"
-    keywords = {token.lower() for token in LATIN_RE.findall(title)}
-    ignored = {"go", "agent", "development", "document", "guide", "note", "over", "and", "with"}
-    return keywords - ignored
+    return keywords_from_title(f"{path.stem} {note_title(path)}")
+
+
+def keywords_from_title(title: str) -> set[str]:
+    return {token.lower() for token in LATIN_RE.findall(title)} - IGNORED_TITLE_KEYWORDS
 
 
 def direct_notes(domain: Domain, marker_name: str) -> list[Path]:
@@ -118,8 +135,16 @@ def generate_relations(
     cross_limit: int,
     cross_minimum: float,
 ) -> dict[Path, list[dict[str, Any]]]:
-    vectors = {note: note_terms(note) for note in notes}
+    # 全库 O(n^2) 配对：每篇笔记只读一次文件，词表/标题关键词/显式链接全部预计算，
+    # 相似度得分只在候选保留时才展开 reasons，避免内层循环重复 I/O。
     texts = {note: note.read_text(encoding="utf-8") for note in notes}
+    vectors = {note: terms_from_text(texts[note]) for note in notes}
+    term_sets = {note: frozenset(vector) for note, vector in vectors.items()}
+    term_sizes = {note: len(terms) for note, terms in term_sets.items()}
+    title_keywords_by_note = {
+        note: keywords_from_title(f"{note.stem} {title_from_text(texts[note], note.stem)}")
+        for note in notes
+    }
     explicit_links = {
         note: {Path(value).stem for value in WIKILINK_RE.findall(texts[note])} for note in notes
     }
@@ -128,11 +153,14 @@ def generate_relations(
         strong: list[dict[str, Any]] = []
         same_domain_semantic: list[dict[str, Any]] = []
         cross_domain_semantic: list[dict[str, Any]] = []
+        source_terms = term_sets[source]
+        source_links = explicit_links[source]
+        source_domain = domain_by_note[source]
         for target in notes:
             if source == target:
                 continue
-            score, reasons = similarity(vectors[source], vectors[target])
-            if target.stem in explicit_links[source]:
+            reasons: list[str] = []
+            if target.stem in source_links:
                 relation_type = "direct-link"
                 score = 1.0
                 reasons = ["正文直接链接"]
@@ -141,19 +169,24 @@ def generate_relations(
                 score = 1.0
                 reasons = ["目标文档引用本文"]
             else:
-                same_domain = domain_by_note[source] == domain_by_note[target]
-                relation_type = (
-                    "same-domain-similarity" if same_domain else "cross-domain-similarity"
-                )
-                if not same_domain:
-                    common_title_keywords = sorted(title_keywords(source) & title_keywords(target))
+                if source_domain == domain_by_note[target]:
+                    relation_type = "same-domain-similarity"
+                else:
+                    common_title_keywords = sorted(
+                        title_keywords_by_note[source] & title_keywords_by_note[target]
+                    )
                     if not common_title_keywords:
                         continue
-                    reasons = [
-                        f"标题共同关键词:{value}" for value in common_title_keywords
-                    ] + reasons
+                    relation_type = "cross-domain-similarity"
+                    reasons = [f"标题共同关键词:{value}" for value in common_title_keywords]
+                target_terms = term_sets[target]
+                common = source_terms & target_terms
+                union_size = term_sizes[source] + term_sizes[target] - len(common)
+                score = len(common) / union_size if union_size else 0.0
             threshold = cross_minimum if relation_type == "cross-domain-similarity" else minimum
             if relation_type in {"direct-link", "backlink"} or score >= threshold:
+                if relation_type not in {"direct-link", "backlink"}:
+                    reasons = reasons + top_reasons(vectors[source], vectors[target], common)
                 item = {
                     "target": str(target.relative_to(vault_root).with_suffix("")),
                     "target_name": target.stem,

{campfire_cli-0.1.3 → campfire_cli-0.1.4}/src/campfire_cli/container.py

@@ -66,6 +66,43 @@ class AppContainer:
             "health": container.maintenance.check(summary=True).model_dump(mode="json"),
         }
 
+    @classmethod
+    def setup_global_resources(cls) -> dict:
+        """无 Workspace 时的降级 setup：同步不依赖 Manifest 的全局资源，跳过其余步骤。"""
+        return {
+            "status": "needs-input",
+            "message": (
+                "未指定 Workspace：已同步全局治理资源；接入 Workspace 后可执行完整 setup。"
+                "按场景选择以下入口之一"
+            ),
+            "paths": [
+                {
+                    "scenario": "接入已有 Vault（目录已存在，含或不含 .campfire.yaml）",
+                    "command": "campfire setup --workspace <vault路径> --default",
+                },
+                {
+                    "scenario": "从零创建新 Workspace（初始化目录结构并注册）",
+                    "command": "campfire workspace create --id <id> --path <路径> --default",
+                },
+                {
+                    "scenario": "已注册 Workspace 的本机资源全量对齐",
+                    "command": "campfire upgrade",
+                },
+            ],
+            "resources": {
+                "skills": cls.build_skill().sync(dry_run=False).model_dump(mode="json"),
+                "agent_hints": cls._inject_hints(),
+            },
+            "skipped": [
+                "workspace-registration",
+                "manifest",
+                "config-check",
+                "bases",
+                "document-index",
+                "health-check",
+            ],
+        }
+
     @classmethod
     def upgrade(cls) -> dict:
         """对齐本机治理资源与当前包版本：Schema 迁移、Skill、Base 与提示词路标。"""

{campfire_cli-0.1.3 → campfire_cli-0.1.4}/src/campfire_cli/main.py

@@ -122,41 +122,17 @@ def tree(ctx: typer.Context) -> None:
 @app.command("setup")
 def setup(
     workspace: Path | None = typer.Option(
-        None, "--workspace", help="要初始化的 Workspace 根目录；缺省时输出接入引导"
+        None, "--workspace", help="要初始化的 Workspace 根目录；缺省时仅同步全局资源并输出接入引导"
     ),
     make_default: bool = typer.Option(False, "--default", help="设为默认 Workspace"),
 ) -> None:
     """从 .campfire.yaml 配置本机，或为已注册 Workspace 创建首份 Manifest。"""
-    if workspace is None:
-        typer.echo(
-            json.dumps(
-                {
-                    "status": "needs-input",
-                    "message": "需要指定 Vault 根目录；按场景选择以下入口之一",
-                    "paths": [
-                        {
-                            "scenario": "接入已有 Vault（目录已存在，含或不含 .campfire.yaml）",
-                            "command": "campfire setup --workspace <vault路径> --default",
-                        },
-                        {
-                            "scenario": "从零创建新 Workspace（初始化目录结构并注册）",
-                            "command": (
-                                "campfire workspace create --id <id> --path <路径> --default"
-                            ),
-                        },
-                        {
-                            "scenario": "暂不接入 Vault，仅安装全局资源（Skill 与提示词路标）",
-                            "command": "campfire upgrade",
-                        },
-                    ],
-                },
-                ensure_ascii=False,
-                indent=2,
-            )
-        )
-        return
     try:
-        result = AppContainer.setup(workspace, make_default)
+        result = (
+            AppContainer.setup_global_resources()
+            if workspace is None
+            else AppContainer.setup(workspace, make_default)
+        )
     except AppError as exc:
         typer.echo(json.dumps({"status": "error", "message": str(exc)}, ensure_ascii=False))
         raise typer.Exit(exc.exit_code) from exc

{campfire_cli-0.1.3 → campfire_cli-0.1.4}/tests/integration/test_cli.py

@@ -2148,8 +2148,13 @@ def test_upgrade_syncs_resources_and_accepts_update_alias(
     assert stale.read_text(encoding="utf-8") != "过时内容\n"
 
 
-def test_setup_without_workspace_prints_guidance(tmp_path: Path, monkeypatch) -> None:
-    monkeypatch.setenv("CAMPFIRE_HOME", str(tmp_path / "home"))
+def test_setup_without_workspace_syncs_global_resources_and_prints_guidance(
+    tmp_path: Path, monkeypatch
+) -> None:
+    home = tmp_path / "home"
+    monkeypatch.setenv("CAMPFIRE_HOME", str(home))
+    hint_file = tmp_path / "CLAUDE.md"
+    monkeypatch.setenv("CAMPFIRE_AGENT_HINT_PATH", str(hint_file))
     result = runner.invoke(app, ["setup"])
     assert result.exit_code == 0, result.output
     payload = json.loads(result.output)
@@ -2158,3 +2163,8 @@ def test_setup_without_workspace_prints_guidance(tmp_path: Path, monkeypatch) ->
     assert "campfire setup --workspace <vault路径> --default" in commands
     assert any("workspace create" in command for command in commands)
     assert any("upgrade" in command for command in commands)
+    assert payload["resources"]["skills"]["status"] == "synced"
+    assert {item["action"] for item in payload["resources"]["agent_hints"]} == {"created"}
+    assert "campfire:agent-hints:start" in hint_file.read_text(encoding="utf-8")
+    assert "manifest" in payload["skipped"]
+    assert "health-check" in payload["skipped"]

{campfire_cli-0.1.3 → campfire_cli-0.1.4}/tests/unit/test_common_governance.py

@@ -106,6 +106,30 @@ class RelationTests(unittest.TestCase):
             self.assertEqual("cross-domain-similarity", relations[left][0]["type"])
             self.assertEqual("Go MCP Server", relations[left][0]["target_name"])
 
+    def test_preserves_all_relation_types_and_reason_order(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            hub = root / "Hub.md"
+            linked = root / "Linked.md"
+            backlinked = root / "Backlinked.md"
+            similar = root / "Similar Note.md"
+            hub.write_text("# Hub\nalpha beta gamma\n[[Linked]]\n", encoding="utf-8")
+            linked.write_text("# Linked\n[[Hub]]\n", encoding="utf-8")
+            backlinked.write_text("# Backlinked\n[[Hub]] delta\n", encoding="utf-8")
+            similar.write_text("# Similar\nalpha beta gamma delta\n", encoding="utf-8")
+            domains = {note: "core" for note in (hub, linked, backlinked, similar)}
+            relations = generate_relations([hub, linked, backlinked, similar], domains, root, 3, 0.1, 2, 0.05)
+            by_type = {item["type"]: item for item in relations[hub]}
+            self.assertEqual({"direct-link", "backlink", "same-domain-similarity"}, set(by_type))
+            self.assertEqual(1.0, by_type["direct-link"]["score"])
+            self.assertEqual(["正文直接链接"], by_type["direct-link"]["reasons"])
+            self.assertEqual(["目标文档引用本文"], by_type["backlink"]["reasons"])
+            self.assertIn("alpha", by_type["same-domain-similarity"]["reasons"])
+            cross = generate_relations(
+                [hub, similar], {hub: "core", similar: "other"}, root, 3, 0.1, 2, 0.05
+            )
+            self.assertEqual([], cross[hub])
+
 
 class RestructureCheckTests(unittest.TestCase):
     def test_before_and_after_accept_unchanged_move(self) -> None: