git-captains-log 0.7.0__tar.gz → 0.7.2__tar.gz

{git_captains_log-0.7.0 → git_captains_log-0.7.2}/.gitignore

@@ -159,3 +159,10 @@ Thumbs.db
 
 # Planhub
 .plan/
+
+# Lavish
+.lavish/
+
+# Mempalace
+mempalace.yaml
+entities.json

{git_captains_log-0.7.0 → git_captains_log-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: git-captains-log
-Version: 0.7.0
+Version: 0.7.2
 Summary: Automatically aggregate git commit messages daily into markdown logs
 Author: Captain's Log Team
 License-File: LICENSE

git_captains_log-0.7.2/docs/README.md

@@ -0,0 +1,34 @@
+# Documentation Map
+
+This repository uses a docs-as-code layout bootstrapped by [adrlane](https://github.com/koradon/adrlane).
+
+## Structure
+
+| Path | Purpose |
+| --- | --- |
+| `docs/specs/` | Feature specifications, behavior, and contracts |
+| `docs/plans/` | Implementation plans derived from specs |
+| `docs/adr/` | Architecture and design decision records |
+| `docs/ideas/` | Early concepts that may be promoted to specs |
+| `docs/roadmap/` | Now / Next / Later horizons for future initiatives |
+| `docs/llm/` | Agent-facing documentation contract and templates |
+
+## How this documentation grows
+
+`adrlane init` creates a minimal core and does not predict future project shape.
+
+When the project gains a new, recurring documentation need (for example CLI reference, runbooks, or API reference), the agent should:
+
+1. Add a new top-level folder under `docs/` when the content does not fit `specs/`, `plans/`, `adr/`, `ideas/`, or `roadmap/`.
+2. Copy a starter template from `docs/llm/templates/` and adapt it.
+3. Update this file to document the new section.
+
+Do not create empty folders "for later". Grow the tree only when there is real content to place there.
+
+Release history lives in Git and release tooling, not in `docs/`.
+
+For the full growth model, see the [adrlane documentation model](https://github.com/koradon/adrlane#documentation-model).
+
+## For agents
+
+Read `docs/llm/AGENT_PROTOCOL.md` first. It defines the doc workflow (`idea -> spec -> plan`) and how to extend the documentation consistently.

git_captains_log-0.7.2/docs/ideas/README.md

@@ -0,0 +1,24 @@
+# Ideas
+
+Ideas are early, uncommitted concepts. The goal is to decide whether a concept deserves further investment.
+
+An idea can flow into:
+
+- a **Spec** (`docs/specs/`) when the desired behavior and contracts become clear
+- a **Plan** (`docs/plans/`) when implementation needs multiple steps or sessions
+
+If an idea does not pass evaluation, the agent may set `## Status` to `rejected` (and optionally link what was decided instead).
+
+## Common flow
+
+1. Create/update an idea in `docs/ideas/`.
+2. When the behavior is clear enough, create a spec in `docs/specs/` and link them in `## Related`.
+3. When implementation is non-trivial, create a plan in `docs/plans/` and link it from the spec.
+
+## Template
+
+Copy and adapt `docs/llm/templates/idea.md`.
+
+## How to stay agnostic
+
+Ideas describe outcomes and constraints without assuming a specific stack (web, backend, CLI, or binaries).

git_captains_log-0.7.2/docs/roadmap/README.md

@@ -0,0 +1,15 @@
+# Roadmap (Now / Next / Later)
+
+The roadmap holds future initiatives without committing to exact dates.
+
+- **Now**: active work or work starting soon (high confidence)
+- **Next**: upcoming work with high confidence, but not started yet
+- **Later**: speculative bets or ideas pending further validation
+
+### Update semantics
+
+- Add items when there is enough clarity to evaluate them.
+- Link roadmap items to the related **Idea**, **Spec**, and/or **Plan** documents.
+- Move items between horizons when confidence changes.
+
+If the project needs more detailed horizon pages, the agent can add them under `docs/roadmap/` using `docs/llm/templates/roadmap.md`.

{git_captains_log-0.7.0 → git_captains_log-0.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "git-captains-log"
-version = "0.7.0"
+version = "0.7.2"
 # dynamic = ["version"]  # Temporarily disabled for release
 description = "Automatically aggregate git commit messages daily into markdown logs"
 authors = [
@@ -36,8 +36,6 @@ packages = ["src"]
 [tool.hatch.build.targets.sdist]
 include = [
     "src/",
-    "commit-msg",
-    "commit-msg-package",
     "README.md",
     "LICENSE",
 ]

{git_captains_log-0.7.0 → git_captains_log-0.7.2}/src/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.7.0'
-__version_tuple__ = version_tuple = (0, 7, 0)
+__version__ = version = '0.7.2'
+__version_tuple__ = version_tuple = (0, 7, 2)
 
 __commit_id__ = commit_id = None

{git_captains_log-0.7.0 → git_captains_log-0.7.2}/src/cli.py

@@ -75,17 +75,12 @@ def setup():
     # Install commit-msg hook
     print("Installing Git commit-msg hook...")
 
-    # Look for commit-msg-package (for package installations) first
-    commit_msg_source = package_dir.parent / "commit-msg-package"
+    # Hook templates ship inside the package (src/hooks/), so this works the
+    # same way for an editable/source install and a real wheel install.
+    hooks_dir = package_dir / "hooks"
+    commit_msg_source = hooks_dir / "commit-msg-package"
     if not commit_msg_source.exists():
-        # Fall back to regular commit-msg (for installation script)
-        commit_msg_source = package_dir.parent / "commit-msg"
-    if not commit_msg_source.exists():
-        # Try alternate location (when installed from wheel)
-        commit_msg_source = Path(__file__).parent.parent / "commit-msg-package"
-    if not commit_msg_source.exists():
-        # Final fallback
-        commit_msg_source = Path(__file__).parent.parent / "commit-msg"
+        commit_msg_source = hooks_dir / "commit-msg"
 
     commit_msg_dest = git_hooks_dir / "commit-msg"
     if commit_msg_source.exists():

{git_captains_log-0.7.0 → git_captains_log-0.7.2}/src/git/git_operations.py

@@ -1,12 +1,35 @@
 """Git operations for Captain's Log."""
 
+import os
 import subprocess
 from pathlib import Path
 
+# Git points these at the invoking repository (and, from a worktree, at its
+# private worktree gitdir/index) via the environment for the whole duration
+# of a hook. `git -C <other_repo>` only changes the directory used to search
+# for a repo and does not override an already-set GIT_DIR/GIT_INDEX_FILE, so
+# without stripping these, git commands "targeting" the log repo actually
+# operate on whichever repo/worktree triggered the hook.
+_GIT_ENV_VARS_TO_STRIP = (
+    "GIT_DIR",
+    "GIT_INDEX_FILE",
+    "GIT_WORK_TREE",
+    "GIT_COMMON_DIR",
+)
+
 
 class GitOperations:
     """Handles git operations for the log repository."""
 
+    # How many times to pull-and-retry a rejected push before giving up.
+    MAX_PUSH_RETRIES = 3
+
+    # Git attribute that makes concurrent same-section appends to the log's
+    # markdown files merge cleanly (keep every unique line from both sides)
+    # instead of producing conflict markers, since entries are always
+    # appended and never edited in place.
+    MERGE_UNION_ATTRIBUTE = "*.md merge=union"
+
     def __init__(self, repo_path: Path):
         """Initialize with repository path.
 
@@ -15,6 +38,19 @@ class GitOperations:
         """
         self.repo_path = repo_path
 
+    def _run_git(self, args: list, **kwargs) -> subprocess.CompletedProcess:
+        """Run a git command scoped to repo_path, immune to inherited repo env vars.
+
+        Args:
+            args: Arguments to pass after "git" (e.g. ["-C", path, "status"])
+            **kwargs: Additional keyword arguments for subprocess.run
+
+        Returns:
+            The completed process
+        """
+        env = {k: v for k, v in os.environ.items() if k not in _GIT_ENV_VARS_TO_STRIP}
+        return subprocess.run(["git"] + args, env=env, **kwargs)
+
     def has_changes(self) -> bool:
         """Check if there are any uncommitted changes in the repository.
 
@@ -22,8 +58,8 @@ class GitOperations:
             True if there are changes, False otherwise
         """
         try:
-            result = subprocess.run(
-                ["git", "-C", str(self.repo_path), "status", "--porcelain"],
+            result = self._run_git(
+                ["-C", str(self.repo_path), "status", "--porcelain"],
                 capture_output=True,
                 text=True,
                 check=True,
@@ -56,8 +92,8 @@ class GitOperations:
         """
         try:
             relative_path = file_path.relative_to(self.repo_path)
-            subprocess.run(
-                ["git", "-C", str(self.repo_path), "add", str(relative_path)],
+            self._run_git(
+                ["-C", str(self.repo_path), "add", str(relative_path)],
                 check=True,
                 capture_output=True,
                 text=True,
@@ -83,8 +119,8 @@ class GitOperations:
             # Get list of changed files from git status
             # Note: git status --porcelain outputs all files (no truncation),
             # but subprocess.run with capture_output=True buffers all output in memory
-            status_result = subprocess.run(
-                ["git", "-C", str(self.repo_path), "status", "--porcelain"],
+            status_result = self._run_git(
+                ["-C", str(self.repo_path), "status", "--porcelain"],
                 check=True,
                 capture_output=True,
                 text=True,
@@ -178,8 +214,8 @@ class GitOperations:
                         # Add individually if batch would be too long or only one file
                         for path in batch:
                             try:
-                                subprocess.run(
-                                    ["git", "-C", str(self.repo_path), "add", path],
+                                self._run_git(
+                                    ["-C", str(self.repo_path), "add", path],
                                     check=True,
                                     capture_output=True,
                                     text=True,
@@ -192,8 +228,8 @@ class GitOperations:
                     else:
                         # Batch add multiple files at once
                         try:
-                            subprocess.run(
-                                ["git", "-C", str(self.repo_path), "add"] + batch,
+                            self._run_git(
+                                ["-C", str(self.repo_path), "add"] + batch,
                                 check=True,
                                 capture_output=True,
                                 text=True,
@@ -220,8 +256,8 @@ class GitOperations:
             True if successful, False otherwise
         """
         try:
-            subprocess.run(
-                ["git", "-C", str(self.repo_path), "commit", "-m", message],
+            self._run_git(
+                ["-C", str(self.repo_path), "commit", "-m", message],
                 check=True,
                 capture_output=True,
                 text=True,
@@ -237,8 +273,8 @@ class GitOperations:
             True if successful, False otherwise
         """
         try:
-            subprocess.run(
-                ["git", "-C", str(self.repo_path), "push"],
+            self._run_git(
+                ["-C", str(self.repo_path), "push"],
                 check=True,
                 capture_output=True,
                 text=True,
@@ -247,6 +283,81 @@ class GitOperations:
         except subprocess.CalledProcessError:
             return False
 
+    def pull(self) -> bool:
+        """Pull changes from the remote, merging into the current branch.
+
+        Uses a plain merge (not rebase): on conflict the working tree is left
+        in a normal "unmerged" state that a clean `git merge --abort` can
+        always recover from, which matters since this runs unattended from a
+        git hook. If a conflict happens anyway, the merge is aborted so we
+        never leave conflict markers sitting in a log file.
+
+        Returns:
+            True if the pull succeeded (including a no-op pull), False if
+            there was nothing to pull from (no remote/offline) or a conflict
+            had to be aborted.
+        """
+        try:
+            self._run_git(
+                ["-C", str(self.repo_path), "pull", "--no-rebase"],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            return True
+        except subprocess.CalledProcessError as e:
+            output = f"{e.stdout or ''}{e.stderr or ''}"
+            if "CONFLICT" in output:
+                self._run_git(
+                    ["-C", str(self.repo_path), "merge", "--abort"],
+                    capture_output=True,
+                    text=True,
+                )
+                print(
+                    "Warning: Pull produced a merge conflict, aborted the merge. "
+                    "Resolve manually by running 'git pull' in the log repository."
+                )
+            else:
+                print(f"Warning: Failed to pull changes: {e.stderr or e}")
+            return False
+
+    def ensure_merge_driver(self) -> bool:
+        """Ensure the log repo's .gitattributes enables union merging for .md files.
+
+        Committing this once (and letting it propagate to every machine via
+        the log repo itself) means concurrent appends to the same day's file
+        from two machines merge automatically instead of conflicting.
+
+        Returns:
+            True if .gitattributes was created or updated, False if it
+            already had the attribute or couldn't be read/written.
+        """
+        gitattributes_path = self.repo_path / ".gitattributes"
+        try:
+            existing = (
+                gitattributes_path.read_text(encoding="utf-8")
+                if gitattributes_path.exists()
+                else ""
+            )
+        except OSError:
+            return False
+
+        if self.MERGE_UNION_ATTRIBUTE in existing:
+            return False
+
+        new_content = existing
+        if new_content and not new_content.endswith("\n"):
+            new_content += "\n"
+        new_content += self.MERGE_UNION_ATTRIBUTE + "\n"
+
+        try:
+            gitattributes_path.write_text(new_content, encoding="utf-8")
+        except OSError:
+            return False
+
+        self.add_file(gitattributes_path)
+        return True
+
     def commit_and_push(self, commit_message: str) -> bool:
         """Perform the complete commit and push workflow.
 
@@ -262,6 +373,8 @@ class GitOperations:
                 print("Warning: Git lock files found, skipping operations")
                 return False
 
+            self.ensure_merge_driver()
+
             # Check if there are any changes to commit
             if not self.has_changes():
                 print("No changes to commit, skipping git operations")
@@ -277,13 +390,23 @@ class GitOperations:
                 print("Warning: Failed to commit changes")
                 return False
 
-            # Push
-            if not self.push():
-                print("Warning: Failed to push changes")
-                return False
+            # Push, retrying with a pull in between if the remote moved on
+            if self.push():
+                print("Successfully committed and pushed log updates")
+                return True
 
-            print("Successfully committed and pushed log updates")
-            return True
+            for attempt in range(1, self.MAX_PUSH_RETRIES + 1):
+                print(
+                    f"Warning: Push rejected, pulling and retrying "
+                    f"({attempt}/{self.MAX_PUSH_RETRIES})..."
+                )
+                self.pull()
+                if self.push():
+                    print("Successfully committed and pushed log updates")
+                    return True
+
+            print("Warning: Failed to push changes")
+            return False
 
         except Exception as e:
             print(f"Warning: Unexpected error during git operations: {e}")

git_captains_log-0.7.2/src/projects/project_finder.py

@@ -0,0 +1,180 @@
+"""Project discovery functionality for Captain's Log."""
+
+import configparser
+from pathlib import Path
+from typing import Optional
+
+from src.config.config_models import Config, ProjectConfig
+from src.projects.project_models import ProjectInfo
+
+
+class ProjectFinder:
+    """Handles finding and identifying projects from repository paths."""
+
+    def __init__(self, config: Config):
+        """Initialize with configuration."""
+        self.config = config
+
+    def find_project(self, repo_path: str) -> ProjectInfo:
+        """Find project information from a repository path.
+
+        Args:
+            repo_path: Path to the repository directory
+
+        Returns:
+            ProjectInfo with project name and configuration
+        """
+        repo_path_abs = Path(repo_path).resolve()
+
+        # Check configured projects first
+        for project_name, project_config in self.config.projects.items():
+            if project_config.root is None:
+                continue
+
+            root_abs = project_config.root.resolve()
+            if root_abs in repo_path_abs.parents or root_abs == repo_path_abs:
+                return ProjectInfo(
+                    name=project_name, config=project_config, base_dir=root_abs
+                )
+
+            # A repo checked out elsewhere (e.g. a treehouse/other pooled
+            # worktree, which never lives under the configured root) still
+            # belongs to this project if its directory name matches one of
+            # root's own nested repos, so umbrella dirs like
+            # ~/git/tripper/{facts-service,tripper-android-app} keep
+            # grouping under "tripper" even when checked out elsewhere.
+            # Matching by name alone would silently misattribute an
+            # unrelated repo that happens to share a common name (e.g.
+            # "docs" or "api"), so we also require the two checkouts to
+            # agree on their origin remote whenever both expose one.
+            nested_repo = root_abs / repo_path_abs.name
+            if (nested_repo / ".git").exists() and self._same_remote(
+                repo_path_abs, nested_repo
+            ):
+                return ProjectInfo(
+                    name=project_name, config=project_config, base_dir=root_abs
+                )
+
+        # Fallback: use repository name as project name
+        project_name = repo_path_abs.name
+        fallback_config = ProjectConfig(root=repo_path_abs)
+
+        return ProjectInfo(
+            name=project_name, config=fallback_config, base_dir=repo_path_abs
+        )
+
+    def _same_remote(self, repo_a: Path, repo_b: Path) -> bool:
+        """Check whether two repos agree on their git origin remote.
+
+        Repos with no resolvable remote (e.g. never pushed, or a local-only
+        checkout) are treated as matching, since name-based matching is the
+        best signal available for them. Repos that both expose a remote
+        must agree, so two unrelated repos sharing a common directory name
+        (e.g. "docs", "api") aren't silently merged into the same project.
+
+        Args:
+            repo_a: First repository directory
+            repo_b: Second repository directory
+
+        Returns:
+            True if the repos are the same project by remote (or lack
+            enough information to tell them apart), False if they have
+            conflicting remotes
+        """
+        remote_a = self._git_remote_url(repo_a)
+        remote_b = self._git_remote_url(repo_b)
+
+        if remote_a is None or remote_b is None:
+            return True
+
+        return remote_a == remote_b
+
+    def _git_remote_url(self, repo: Path) -> Optional[str]:
+        """Read the "origin" remote URL from a repo's git config, if any.
+
+        Args:
+            repo: Path to the git repository (containing a `.git` dir or,
+                for a worktree checkout, a `.git` file pointing elsewhere)
+
+        Returns:
+            The origin remote URL, or None if unavailable
+        """
+        git_dir = self._resolve_common_git_dir(repo)
+        if git_dir is None:
+            return None
+
+        config_path = git_dir / "config"
+        if not config_path.is_file():
+            return None
+
+        parser = configparser.RawConfigParser()
+        try:
+            parser.read(config_path)
+            return parser.get('remote "origin"', "url", fallback=None)
+        except configparser.Error:
+            return None
+
+    def _resolve_common_git_dir(self, repo: Path) -> Optional[Path]:
+        """Resolve the shared git directory a repo checkout belongs to.
+
+        For a regular checkout this is just `<repo>/.git`. For a `git
+        worktree` checkout, `.git` is a file containing a `gitdir:` pointer
+        into the main repo's `.git/worktrees/<name>` directory, which in
+        turn has a `commondir` file pointing at the actual shared git dir
+        (where `config` and remotes live) - so both need to be followed.
+
+        Args:
+            repo: Path to the repository directory
+
+        Returns:
+            The resolved git directory, or None if it can't be determined
+        """
+        dot_git = repo / ".git"
+
+        if dot_git.is_dir():
+            return dot_git
+
+        if not dot_git.is_file():
+            return None
+
+        try:
+            contents = dot_git.read_text().strip()
+        except OSError:
+            return None
+
+        if not contents.startswith("gitdir:"):
+            return None
+
+        worktree_git_dir = Path(contents.split(":", 1)[1].strip())
+        if not worktree_git_dir.is_absolute():
+            worktree_git_dir = (repo / worktree_git_dir).resolve()
+
+        commondir_file = worktree_git_dir / "commondir"
+        if not commondir_file.is_file():
+            return worktree_git_dir
+
+        try:
+            common_dir_rel = commondir_file.read_text().strip()
+        except OSError:
+            return worktree_git_dir
+
+        return (worktree_git_dir / common_dir_rel).resolve()
+
+    def get_project_by_name(self, project_name: str) -> Optional[ProjectInfo]:
+        """Get project information by name.
+
+        Args:
+            project_name: Name of the project
+
+        Returns:
+            ProjectInfo if found, None otherwise
+        """
+        project_config = self.config.projects.get(project_name)
+        if project_config is None:
+            return None
+
+        return ProjectInfo(
+            name=project_name,
+            config=project_config,
+            base_dir=project_config.root or Path.cwd(),
+        )

{git_captains_log-0.7.0 → git_captains_log-0.7.2}/src/stone.py

@@ -95,12 +95,17 @@ def append_milestone_entry(
     file_path.write_text(content, encoding="utf-8")
 
 
-def build_milestone_context() -> MilestoneContext:
-    """Build the milestone context from the current working directory."""
+def resolve_project() -> tuple[Config, ProjectInfo]:
+    """Resolve the config and project for the current working directory."""
     config = load_config()
     project_finder = ProjectFinder(config)
     cwd = Path.cwd()
     project = project_finder.find_project(str(cwd))
+    return config, project
+
+
+def build_milestone_context(config: Config, project: ProjectInfo) -> MilestoneContext:
+    """Build the milestone context for an already-resolved config and project."""
     today = date.today()
     file_path = get_milestone_file_path(config, project, today)
     return MilestoneContext(
@@ -110,13 +115,23 @@ def build_milestone_context() -> MilestoneContext:
 
 def add_milestone_entry(entry_text: str) -> None:
     """High-level API to add a milestone entry for the current project."""
-    ctx = build_milestone_context()
+    config, project = resolve_project()
+
+    # Pull remote changes before deciding where the entry goes, since the
+    # destination (flat milestone.md vs <year>/milestone.md) depends on
+    # whether a <year>/ directory already exists locally. Pulling first
+    # ensures a rollover pushed from another machine (or directly on GitHub)
+    # is reflected in that decision, instead of writing to a now-stale path.
+    log_repo_path = project.log_repo or config.global_log_repo
+    if log_repo_path is not None:
+        GitOperations(log_repo_path).pull()
+
+    ctx = build_milestone_context(config, project)
     emoji = random.choice(EMOJIS)
 
     append_milestone_entry(ctx.file_path, ctx.log_date, entry_text, emoji)
 
     # Commit and push if we have a git repository backing the logs
-    log_repo_path = ctx.project.log_repo or ctx.config.global_log_repo
     if log_repo_path is not None:
         git_ops = GitOperations(log_repo_path)
         commit_message = (

{git_captains_log-0.7.0 → git_captains_log-0.7.2}/src/update_log.py

@@ -152,6 +152,12 @@ def main():
         log_manager = LogManager(config)
         log_info = log_manager.get_log_file_info(project)
 
+        # Pull remote changes before reading the log, so a push made from
+        # another machine (or directly on GitHub) is already reflected in
+        # what we load and merge into below.
+        if log_info.has_git_repo and log_info.log_repo_path:
+            GitOperations(log_info.log_repo_path).pull()
+
         # Load existing log data
         log_data = log_manager.load_log(log_info)
 

{git_captains_log-0.7.0 → git_captains_log-0.7.2}/src/wnext.py

@@ -42,6 +42,12 @@ def add_what_next_entry(entry_text: str, project_name: Optional[str], use_other:
     log_manager = LogManager(config)
     log_info = log_manager.get_log_file_info(project)
 
+    # Pull remote changes before reading the log, so a push made from
+    # another machine (or directly on GitHub) is already reflected in
+    # what we load and merge into below.
+    if log_info.has_git_repo and log_info.log_repo_path:
+        GitOperations(log_info.log_repo_path).pull()
+
     # Load existing log data
     log_data = log_manager.load_log(log_info)
 

{git_captains_log-0.7.0 → git_captains_log-0.7.2}/src/wtf.py

@@ -37,6 +37,12 @@ def add_wtf_entry(entry_text: str):
     log_manager = LogManager(config)
     log_info = log_manager.get_log_file_info(project)
 
+    # Pull remote changes before reading the log, so a push made from
+    # another machine (or directly on GitHub) is already reflected in
+    # what we load and merge into below.
+    if log_info.has_git_repo and log_info.log_repo_path:
+        GitOperations(log_info.log_repo_path).pull()
+
     # Load existing log data
     log_data = log_manager.load_log(log_info)
 

git_captains_log-0.7.0/src/projects/project_finder.py

@@ -1,64 +0,0 @@
-"""Project discovery functionality for Captain's Log."""
-
-from pathlib import Path
-from typing import Optional
-
-from src.config.config_models import Config, ProjectConfig
-from src.projects.project_models import ProjectInfo
-
-
-class ProjectFinder:
-    """Handles finding and identifying projects from repository paths."""
-
-    def __init__(self, config: Config):
-        """Initialize with configuration."""
-        self.config = config
-
-    def find_project(self, repo_path: str) -> ProjectInfo:
-        """Find project information from a repository path.
-
-        Args:
-            repo_path: Path to the repository directory
-
-        Returns:
-            ProjectInfo with project name and configuration
-        """
-        repo_path_abs = Path(repo_path).resolve()
-
-        # Check configured projects first
-        for project_name, project_config in self.config.projects.items():
-            if project_config.root is None:
-                continue
-
-            root_abs = project_config.root.resolve()
-            if root_abs in repo_path_abs.parents or root_abs == repo_path_abs:
-                return ProjectInfo(
-                    name=project_name, config=project_config, base_dir=root_abs
-                )
-
-        # Fallback: use repository name as project name
-        project_name = repo_path_abs.name
-        fallback_config = ProjectConfig(root=repo_path_abs)
-
-        return ProjectInfo(
-            name=project_name, config=fallback_config, base_dir=repo_path_abs
-        )
-
-    def get_project_by_name(self, project_name: str) -> Optional[ProjectInfo]:
-        """Get project information by name.
-
-        Args:
-            project_name: Name of the project
-
-        Returns:
-            ProjectInfo if found, None otherwise
-        """
-        project_config = self.config.projects.get(project_name)
-        if project_config is None:
-            return None
-
-        return ProjectInfo(
-            name=project_name,
-            config=project_config,
-            base_dir=project_config.root or Path.cwd(),
-        )