cribsheet 0.2.1__tar.gz → 0.2.2__tar.gz

{cribsheet-0.2.1 → cribsheet-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cribsheet
-Version: 0.2.1
+Version: 0.2.2
 Summary: Local MCP server: markdown memory with a Chroma embedding index
 Requires-Python: >=3.13
 Requires-Dist: chromadb>=0.5

{cribsheet-0.2.1 → cribsheet-0.2.2}/crib/app.py

@@ -914,14 +914,62 @@ class Crib:
                     seen.add(p)
         return sorted(seen)
 
+    def _registered_root(self, project: str | None) -> Path | None:
+        """Where `project` was last indexed from: the symbol_index's `.source_root`,
+        else a sole in-situ doc root. None when unrecorded — or when the recorded
+        dir is gone, so a moved checkout can be re-rooted from its new path."""
+        if not project:
+            return None
+        from .codeindex import SymbolIndex
+        root = SymbolIndex(self.paths.project_dir(project)).source_root()
+        if root is None:
+            doc_roots = {Path(r) for r in self._source_roots(project).all().values()}
+            if len(doc_roots) == 1:
+                root = doc_roots.pop()
+        return root.resolve() if root is not None and root.is_dir() else None
+
     def _ensure_crib(self, cwd: Path | None, project: str | None,
                      want_code: bool, want_docs: bool) -> tuple[Any, bool]:
         """Find the repo's `.crib`, or CREATE one with sensible defaults (project =
         repo dir name; auto-detected code `paths:` + doc `docs:` globs indexed
         in-situ). Returns (CribLink, created?). The one primitive both `project
-        setup` and the facet setups defer to."""
-        base = (Path(cwd) if cwd else Path.cwd()).resolve()
-        link = CribLink.find(base)
+        setup` and the facet setups defer to.
+
+        Root resolution NEVER falls back to the process cwd — in the daemon that's
+        just wherever sharedserver spawned it, and a `project_index(project=zdot)`
+        once re-rooted zdot into an unrelated checkout that way. An explicit `cwd`
+        (the caller's project_path) decides; a bare `project` resolves to the root
+        it was last indexed from (`_registered_root`); neither → error. A cwd whose
+        `.crib` names a DIFFERENT project than an explicit `project` is treated as
+        incidental (the CLI ships the shell cwd with every call), so the project's
+        registered root wins; with no registered root to prefer it's an error —
+        never index one project's repo into another."""
+        base = Path(cwd).resolve() if cwd else None
+        link = CribLink.find(base) if base is not None else None
+        if project and (link is None or link.project != project):
+            # `base` (if any) isn't visibly `project`'s repo — resolve the name to
+            # the root it was last indexed from before trusting an incidental cwd.
+            reg = self._registered_root(project)
+            if reg is not None:
+                base, link = reg, CribLink.find(reg)
+                if link is not None and link.project != project:
+                    raise ValueError(
+                        f"stale registration: {project!r} was last indexed from "
+                        f"{reg}, but the .crib there now names {link.project!r}. "
+                        "Pass project_path=<the repo dir> explicitly (or "
+                        "project_forget the stale project).")
+            elif link is not None:
+                raise ValueError(
+                    f"{base} belongs to project {link.project!r} (its .crib says "
+                    f"so), not {project!r} — refusing to index one project's repo "
+                    f"into another. Pass project_path=<{project}'s repo dir>.")
+            # else: no .crib and no registered root → first-time onboard of
+            # `project` at `base` (the create path below).
+        if base is None:
+            raise ValueError(
+                f"can't locate a repo for project {project!r}: it has no recorded "
+                "source root. Pass project_path=<the repo dir> — a repo-scoped op "
+                "never falls back to the server's own cwd.")
         if link and link.root:
             return link, False
         # Anchor at the nearest repo marker, else at `base` ITSELF — never escape to
@@ -934,6 +982,14 @@ class Crib:
                 root = d
                 break
         name = project or root.name.replace(" ", "-")
+        if not project and (reg := self._registered_root(name)) is not None \
+                and reg != root.resolve():
+            # dir-name collision with an existing project rooted elsewhere — a
+            # fresh .crib here would silently merge two repos under one project
+            raise ValueError(
+                f"a project named {name!r} already exists, rooted at {reg} — "
+                f"refusing to also bind {root} to it. Add a .crib here naming a "
+                "different project (or project_forget the old one to re-root).")
         lines = ["# Auto-created by `crib project setup` — ties this repo to a crib "
                  "project.", f"project: {name}"]
         # globs are quoted: a bare `- **/*.py` makes YAML read `*` as an alias anchor.
@@ -958,11 +1014,12 @@ class Crib:
         explicit verb.)"""
         link, created = self._ensure_crib(cwd, project, want_code=True, want_docs=True)
         proj = project or link.project
-        docs = await self.index_docs_insitu(proj, cwd) if link.doc_patterns else {}
+        new_project = proj not in self.projects()   # before indexing creates its dirs
+        docs = await self.index_docs_insitu(proj, link.root) if link.doc_patterns else {}
         globs = link.paths or self._detect_code_globs(link.root)
         code = await self._index_project_code(proj, link.root, globs)
         return {"project": proj, "root": str(link.root), "crib_created": created,
-                "docs_indexed": docs.get("docs", 0), **code}
+                "created": new_project, "docs_indexed": docs.get("docs", 0), **code}
 
     async def project_index(self, project: str | None = None,
                             cwd: Path | None = None) -> dict[str, Any]:
@@ -970,11 +1027,12 @@ class Crib:
         (ensuring a `.crib` first). Cheap re-run via the content-hash gate."""
         link, created = self._ensure_crib(cwd, project, want_code=True, want_docs=False)
         proj = project or link.project
-        docs = await self.index_docs_insitu(proj, cwd) if link.doc_patterns else {}
+        new_project = proj not in self.projects()   # before indexing creates its dirs
+        docs = await self.index_docs_insitu(proj, link.root) if link.doc_patterns else {}
         globs = link.paths or self._detect_code_globs(link.root)
         code = await self._index_project_code(proj, link.root, globs)
         return {"project": proj, "root": str(link.root), "crib_created": created,
-                "docs_indexed": docs.get("docs", 0), **code}
+                "created": new_project, "docs_indexed": docs.get("docs", 0), **code}
 
     def _project_refs(self, proj: str) -> list[dict[str, Any]]:
         """Delegate to Refs (crib/refs.py) — a project's `.crib` refs: targets."""
@@ -1334,9 +1392,15 @@ class Crib:
         source-anchored note keyed `sources/<repo>/<rel>`; `read`/`locate` return
         the repo file, so an LLM that edits it edits the master. Re-runnable
         (hash-gated), and it prunes docs deleted from the source."""
-        link = CribLink.find(cwd or Path.cwd())
+        # No process-cwd fallback: in the daemon that's the spawn dir, not a repo.
+        base = Path(cwd) if cwd else self._registered_root(project)
+        if base is None:
+            raise ValueError(
+                "no repo dir to scan: pass project_path=<the repo dir> (or name an "
+                "already-indexed project)")
+        link = CribLink.find(base)
         if link is None or link.root is None:
-            raise ValueError("no .crib found from cwd upward")
+            raise ValueError(f"no .crib found from {base} upward")
         proj = project or link.project
         repo = link.root.name
         prefix = f"{SRC_PREFIX}{repo}/"
@@ -1439,7 +1503,12 @@ class Crib:
         history/identity survive; files removed upstream are dropped (reconcile,
         scoped to THIS host). Records a binding for the daemon's live mirror.
         """
-        start = root or cwd or Path.cwd()
+        # No process-cwd fallback: in the daemon that's the spawn dir, not a repo.
+        start = root or cwd
+        if start is None:
+            raise ValueError(
+                "no repo dir to anchor the memory lookup: pass project_path=<the "
+                "repo dir> (or root=<the harness project root>)")
         src_root = root or claudemem.find_harness_root(start)
         if src_root is None or not claudemem.harness_memory_dir(src_root).is_dir():
             raise ValueError(

{cribsheet-0.2.1 → cribsheet-0.2.2}/crib/codeindex.py

@@ -58,6 +58,21 @@ DEFAULT_LSP_SPECS: dict[str, dict[str, Any]] = {
     "clangd": {"command": "clangd", "args": [],
                "extensionToLanguage": {".c": "c", ".h": "c", ".cc": "cpp",
                                        ".cpp": "cpp", ".hpp": "cpp", ".hh": "cpp"}},
+    # TypeScript/JavaScript: typescript-language-server (tsserver over LSP —
+    # documentSymbol + references + callHierarchy, all verified) first; vtsls
+    # (the VSCode-flavoured tsserver wrapper, same capabilities) as the fallback.
+    "typescript-language-server": {
+        "command": "typescript-language-server", "args": ["--stdio"],
+        "extensionToLanguage": {".ts": "typescript", ".tsx": "typescriptreact",
+                                ".mts": "typescript", ".cts": "typescript",
+                                ".js": "javascript", ".jsx": "javascriptreact",
+                                ".mjs": "javascript", ".cjs": "javascript"}},
+    "vtsls": {
+        "command": "vtsls", "args": ["--stdio"],
+        "extensionToLanguage": {".ts": "typescript", ".tsx": "typescriptreact",
+                                ".mts": "typescript", ".cts": "typescript",
+                                ".js": "javascript", ".jsx": "javascriptreact",
+                                ".mjs": "javascript", ".cjs": "javascript"}},
     # Lua: emmylua_ls (Rust rewrite, aims for full LSP incl. call hierarchy) first,
     # lua-language-server (LuaLS — references/definition but NO call hierarchy) as
     # the fallback. Even without call hierarchy, descriptions + callers-via-references

{cribsheet-0.2.1 → cribsheet-0.2.2}/crib/server.py

@@ -382,8 +382,10 @@ def build_server(crib: Crib | None = None):
         indexed, do THIS, don't fall back to grep. Ensures a `.crib` (auto-created with
         sensible defaults if missing), imports the repo's docs into notes, AND indexes
         all its source code (functions/classes/globals/members + call graph +
-        references + descriptions). Pass `project_path=<the repo dir>`. Idempotent. Then
-        code_lookup/code_dossier work. Code-only variant: project_index."""
+        references + descriptions). Pass `project_path=<the repo dir>` (a bare
+        `project=<name>` works only for an already-indexed project — it resolves the
+        recorded root). Idempotent. Then code_lookup/code_dossier work. Code-only
+        variant: project_index."""
         return _switch_if_created(
             await crib.project_setup(_source_project(crib, project, project_path),
                                      cwd=_cwd(project_path)))
@@ -394,7 +396,9 @@ def build_server(crib: Crib | None = None):
         """(Re)index a project's SOURCE CODE from its `.crib` (code facet of
         project_setup — no doc import). Use to index a repo for code_lookup/code_dossier,
         or to refresh after edits (cheap: unchanged files are skipped). Pass
-        `project_path=<the repo dir>`; a `.crib` is auto-created if missing."""
+        `project_path=<the repo dir>` (a `.crib` is auto-created if missing); a bare
+        `project=<name>` re-indexes an ALREADY-INDEXED project from its recorded
+        root — an unknown name errors rather than guessing a directory."""
         return _switch_if_created(
             await crib.project_index(_source_project(crib, project, project_path),
                                      cwd=_cwd(project_path)))

{cribsheet-0.2.1 → cribsheet-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cribsheet"
-version = "0.2.1"
+version = "0.2.2"
 description = "Local MCP server: markdown memory with a Chroma embedding index"
 readme = "README.md"
 requires-python = ">=3.13"

cribsheet-0.2.2/tests/test_project_resolution.py

@@ -0,0 +1,204 @@
+"""Repo-scoped ops must resolve their project from `project_path`'s `.crib`, not
+the sticky session project. Regression: a project_index(project_path=/other/repo)
+with a sticky current project once indexed the OTHER repo INTO the current one."""
+
+from __future__ import annotations
+
+import pytest
+
+from crib.app import Crib
+from crib.config import Config
+from crib.paths import Paths
+from crib.server import _source_project, _write_project
+from crib.session import session_state
+from crib.store import InMemoryStore
+
+
+@pytest.fixture()
+def crib(tmp_path, monkeypatch):
+    monkeypatch.setenv("CRIB_CONFIG_DIR", str(tmp_path / "config"))
+    monkeypatch.setenv("CRIB_DATA_DIR", str(tmp_path / "data"))
+    monkeypatch.setenv("CRIB_INDEX_DIR", str(tmp_path / "index"))
+    return Crib(Paths.resolve().ensure(), Config(), InMemoryStore())
+
+
+def test_explicit_project_wins(crib):
+    assert _source_project(crib, "chosen", "/some/repo") == "chosen"
+
+
+def test_project_path_defers_to_crib_not_sticky(crib):
+    # sticky session is on some project…
+    session_state().current_project = "cribsheet"
+    # …but a repo-scoped call names a DIFFERENT repo via project_path → return None
+    # so crib.project_* reads link.project from THAT repo's .crib (never the sticky).
+    assert _source_project(crib, None, "/Users/me/other-repo") is None
+
+
+def test_no_path_falls_back_to_session(crib):
+    session_state().current_project = "sticky-proj"
+    assert _source_project(crib, None, None) == "sticky-proj"
+
+
+def test_write_tools_carry_project_or_path_anyof(crib):
+    # the wire schema declares "project OR project_path required" (anyOf), so a
+    # validating client enforces it up front — not only the runtime guard.
+    import asyncio
+
+    from crib.server import build_server
+    mcp = build_server(crib)
+
+    async def schema(name):
+        return (await mcp.get_tool(name)).to_mcp_tool().inputSchema
+
+    want = [{"required": ["project"]}, {"required": ["project_path"]}]
+    for w in ("note_store", "note_append", "note_edit", "note_forget", "note_move"):
+        assert asyncio.run(schema(w)).get("anyOf") == want, w
+    for r in ("note_lookup", "note_read", "code_lookup"):   # reads are unconstrained
+        assert asyncio.run(schema(r)).get("anyOf") is None, r
+
+
+def test_write_project_elicits_when_target_omitted(crib):
+    import asyncio
+
+    from crib.server import _write_project_elicit
+
+    class _Accepted:                       # mimics fastmcp AcceptedElicitation
+        def __init__(self, data): self.data = data
+
+    class _Ctx:
+        def __init__(self, behaviour): self.behaviour = behaviour
+        async def elicit(self, message, response_type=None):
+            if self.behaviour == "accept":
+                return _Accepted("chosen-proj")
+            if self.behaviour == "decline":
+                return object()            # no .data → treated as declined
+            raise RuntimeError("client has no elicitation capability")
+
+    run = asyncio.run
+    # explicit project short-circuits (never elicits)
+    assert run(_write_project_elicit(crib, "shuck", None, _Ctx("accept"))) == "shuck"
+    # omitted → elicited value is used
+    assert run(_write_project_elicit(crib, None, None, _Ctx("accept"))) == "chosen-proj"
+    # declined or unsupported → falls back to the hard error
+    for b in ("decline", "unsupported"):
+        with pytest.raises(ValueError, match="explicit target"):
+            run(_write_project_elicit(crib, None, None, _Ctx(b)))
+
+
+def test_write_project_requires_explicit_target(crib):
+    # writes never inherit the sticky session — a fact belongs to its subject's project
+    session_state().current_project = "some-repo-im-browsing"
+    with pytest.raises(ValueError, match="explicit target"):
+        _write_project(crib, None, None)
+    # explicit project wins
+    assert _write_project(crib, "shuck", None) == "shuck"
+    # project_path resolves via that repo's .crib (here: no .crib → default)
+    assert _write_project(crib, None, str(crib.paths.data_dir)) == crib.config.default_project
+
+
+# ── Repo-root resolution for repo-scoped ops (never the daemon's own cwd) ───────
+# Regression: `project_index(project="zdot")` from the daemon (whose process cwd
+# was an unrelated checkout) fell back to Path.cwd(), wrote a .crib claiming zdot
+# there, and re-rooted the project. A bare name must resolve the recorded root;
+# with nothing recorded it must ERROR, not claim whatever dir the process is in.
+
+def _crib_repo(tmp_path, name, project=None):
+    """A repo dir with a .git marker and a .crib naming `project` (default: name)."""
+    repo = tmp_path / name
+    (repo / ".git").mkdir(parents=True)
+    (repo / ".crib").write_text(f"project: {project or name}\n")
+    return repo
+
+
+def _register(crib, project, root):
+    """Record `root` as `project`'s indexed source root (what indexing persists)."""
+    from crib.codeindex import SymbolIndex
+    SymbolIndex(crib.paths.project_dir(project)).set_source_root(root)
+
+
+def test_named_project_resolves_registered_root(crib, tmp_path):
+    repo = _crib_repo(tmp_path, "alpha")
+    _register(crib, "alpha", repo)
+    link, created = crib._ensure_crib(None, "alpha", want_code=True, want_docs=False)
+    assert not created and link.root == repo and link.project == "alpha"
+
+
+def test_named_project_end_to_end_index_uses_registered_root(crib, tmp_path):
+    # the zdot repro: explicit project=, no path — must act on the recorded repo
+    import asyncio
+    repo = _crib_repo(tmp_path, "alpha")
+    _register(crib, "alpha", repo)
+    out = asyncio.run(crib.project_index(project="alpha"))
+    assert out["root"] == str(repo) and not out["crib_created"]
+    assert not out["created"]                    # existing project — no session switch
+
+
+def test_unknown_project_with_no_path_errors_not_cwd(crib, monkeypatch, tmp_path):
+    # even with the process cwd sitting in a plausible repo, a bare unknown name
+    # must error — never claim the cwd
+    decoy = _crib_repo(tmp_path, "decoy")
+    monkeypatch.chdir(decoy)
+    with pytest.raises(ValueError, match="never falls back"):
+        crib._ensure_crib(None, "ghost", want_code=True, want_docs=False)
+    assert (decoy / ".crib").read_text() == "project: decoy\n"   # untouched
+
+
+def test_incidental_cwd_of_other_repo_defers_to_registered_root(crib, tmp_path):
+    # the CLI ships the shell cwd with every call — `crib project index alpha`
+    # run from inside beta's repo must still act on alpha's recorded root
+    alpha = _crib_repo(tmp_path, "alpha")
+    beta = _crib_repo(tmp_path, "beta")
+    _register(crib, "alpha", alpha)
+    link, created = crib._ensure_crib(beta, "alpha", want_code=True, want_docs=False)
+    assert not created and link.root == alpha and link.project == "alpha"
+
+
+def test_mismatched_path_without_registered_root_errors(crib, tmp_path):
+    # explicit project naming ANOTHER repo's .crib, and nothing recorded to prefer:
+    # refuse — never index one project's repo into another
+    beta = _crib_repo(tmp_path, "beta")
+    with pytest.raises(ValueError, match="refusing to index"):
+        crib._ensure_crib(beta, "alpha", want_code=True, want_docs=False)
+
+
+def test_create_refuses_dirname_collision_with_existing_project(crib, tmp_path):
+    # a fresh repo whose DIR NAME matches an existing project rooted elsewhere:
+    # auto-creating a .crib would silently merge two repos under one project
+    original = _crib_repo(tmp_path / "a", "myrepo")
+    _register(crib, "myrepo", original)
+    clone = tmp_path / "b" / "myrepo"
+    (clone / ".git").mkdir(parents=True)
+    with pytest.raises(ValueError, match="already exists"):
+        crib._ensure_crib(clone, None, want_code=True, want_docs=False)
+    assert not (clone / ".crib").exists()
+
+
+def test_stale_registration_errors(crib, tmp_path):
+    # recorded root's .crib was rewritten to another project → surface it
+    repo = _crib_repo(tmp_path, "alpha", project="beta")
+    _register(crib, "alpha", repo)
+    with pytest.raises(ValueError, match="stale registration"):
+        crib._ensure_crib(None, "alpha", want_code=True, want_docs=False)
+
+
+def test_insitu_docs_and_memory_import_require_repo_dir(crib):
+    import asyncio
+    with pytest.raises(ValueError, match="pass project_path"):
+        asyncio.run(crib.index_docs_insitu())
+    with pytest.raises(ValueError, match="pass project_path"):
+        asyncio.run(crib.import_claude_memory())
+
+
+def test_switch_if_created_fires_on_project_creation(crib, tmp_path):
+    # DESIGN §15: creating a project switches the session into it. Regression:
+    # the switch keyed on "created", which setup/index never returned.
+    import asyncio
+
+    from crib.server import _switch_if_created
+    repo = tmp_path / "fresh"
+    (repo / ".git").mkdir(parents=True)
+    out = asyncio.run(crib.project_index(cwd=repo))
+    assert out["crib_created"] and out["created"]
+    session_state().current_project = None
+    _switch_if_created(out)
+    assert session_state().current_project == "fresh"

cribsheet-0.2.1/tests/test_project_resolution.py

@@ -1,96 +0,0 @@
-"""Repo-scoped ops must resolve their project from `project_path`'s `.crib`, not
-the sticky session project. Regression: a project_index(project_path=/other/repo)
-with a sticky current project once indexed the OTHER repo INTO the current one."""
-
-from __future__ import annotations
-
-import pytest
-
-from crib.app import Crib
-from crib.config import Config
-from crib.paths import Paths
-from crib.server import _source_project, _write_project
-from crib.session import session_state
-from crib.store import InMemoryStore
-
-
-@pytest.fixture()
-def crib(tmp_path, monkeypatch):
-    monkeypatch.setenv("CRIB_CONFIG_DIR", str(tmp_path / "config"))
-    monkeypatch.setenv("CRIB_DATA_DIR", str(tmp_path / "data"))
-    monkeypatch.setenv("CRIB_INDEX_DIR", str(tmp_path / "index"))
-    return Crib(Paths.resolve().ensure(), Config(), InMemoryStore())
-
-
-def test_explicit_project_wins(crib):
-    assert _source_project(crib, "chosen", "/some/repo") == "chosen"
-
-
-def test_project_path_defers_to_crib_not_sticky(crib):
-    # sticky session is on some project…
-    session_state().current_project = "cribsheet"
-    # …but a repo-scoped call names a DIFFERENT repo via project_path → return None
-    # so crib.project_* reads link.project from THAT repo's .crib (never the sticky).
-    assert _source_project(crib, None, "/Users/me/other-repo") is None
-
-
-def test_no_path_falls_back_to_session(crib):
-    session_state().current_project = "sticky-proj"
-    assert _source_project(crib, None, None) == "sticky-proj"
-
-
-def test_write_tools_carry_project_or_path_anyof(crib):
-    # the wire schema declares "project OR project_path required" (anyOf), so a
-    # validating client enforces it up front — not only the runtime guard.
-    import asyncio
-
-    from crib.server import build_server
-    mcp = build_server(crib)
-
-    async def schema(name):
-        return (await mcp.get_tool(name)).to_mcp_tool().inputSchema
-
-    want = [{"required": ["project"]}, {"required": ["project_path"]}]
-    for w in ("note_store", "note_append", "note_edit", "note_forget", "note_move"):
-        assert asyncio.run(schema(w)).get("anyOf") == want, w
-    for r in ("note_lookup", "note_read", "code_lookup"):   # reads are unconstrained
-        assert asyncio.run(schema(r)).get("anyOf") is None, r
-
-
-def test_write_project_elicits_when_target_omitted(crib):
-    import asyncio
-
-    from crib.server import _write_project_elicit
-
-    class _Accepted:                       # mimics fastmcp AcceptedElicitation
-        def __init__(self, data): self.data = data
-
-    class _Ctx:
-        def __init__(self, behaviour): self.behaviour = behaviour
-        async def elicit(self, message, response_type=None):
-            if self.behaviour == "accept":
-                return _Accepted("chosen-proj")
-            if self.behaviour == "decline":
-                return object()            # no .data → treated as declined
-            raise RuntimeError("client has no elicitation capability")
-
-    run = asyncio.run
-    # explicit project short-circuits (never elicits)
-    assert run(_write_project_elicit(crib, "shuck", None, _Ctx("accept"))) == "shuck"
-    # omitted → elicited value is used
-    assert run(_write_project_elicit(crib, None, None, _Ctx("accept"))) == "chosen-proj"
-    # declined or unsupported → falls back to the hard error
-    for b in ("decline", "unsupported"):
-        with pytest.raises(ValueError, match="explicit target"):
-            run(_write_project_elicit(crib, None, None, _Ctx(b)))
-
-
-def test_write_project_requires_explicit_target(crib):
-    # writes never inherit the sticky session — a fact belongs to its subject's project
-    session_state().current_project = "some-repo-im-browsing"
-    with pytest.raises(ValueError, match="explicit target"):
-        _write_project(crib, None, None)
-    # explicit project wins
-    assert _write_project(crib, "shuck", None) == "shuck"
-    # project_path resolves via that repo's .crib (here: no .crib → default)
-    assert _write_project(crib, None, str(crib.paths.data_dir)) == crib.config.default_project