Function init_baseline

src/watcher/watcher.c:1166–1240

Init baseline for a project: check if git, get HEAD, count files */

/* Init baseline for a project: check if git, get HEAD, count files */
static bool init_baseline(cbm_watcher_t *w, project_state_t *s) {
    struct stat st;
    if (stat(s->root_path, &st) != 0) {
        cbm_log_warn("watcher.root_gone", "project", s->project_name, "path", s->root_path);
        s->baseline_done = true;
        s->is_git = false;
        return true;
    }

    watcher_git_status_t repository_status = git_repo_status(w, s);
    if (repository_status != WATCHER_GIT_OK && repository_status != WATCHER_GIT_COMMAND_FAILED) {
        return false;
    }
    s->is_git = repository_status == WATCHER_GIT_OK;

    /* `rev-parse --git-dir` walks UP, so an ordinary folder that merely happens
     * to live under some unrelated repository answers yes. Treating it as a git
     * project is what produced the runaway churn: it inherits the ancestor's
     * dirty state, which is permanently non-empty and has nothing to do with
     * this directory, so every poll looked like a change.
     *
     * A directory is only really git-managed here if it carries its own .git,
     * or the ancestor repository actually tracks something inside it. A
     * genuine sub-package of a monorepo passes the second test; a scratch or
     * gitignored folder sitting under a repo fails both and is polled as a
     * plain directory instead. */
    if (s->is_git && !git_has_own_dot_git(s->root_path)) {
        bool tracked = false;
        watcher_git_status_t tracked_status = git_tracks_anything_here(w, s, &tracked);
        if (tracked_status != WATCHER_GIT_OK && tracked_status != WATCHER_GIT_COMMAND_FAILED) {
            return false;
        }
        if (!tracked) {
            s->is_git = false;
            cbm_log_info("watcher.nested_non_git", "project", s->project_name, "path",
                         s->root_path);
        }
    }

    s->baseline_done = true;

    if (s->is_git) {
        watcher_git_status_t cdup_status = git_repo_cdup(w, s, s->repo_cdup, sizeof(s->repo_cdup));
        if (cdup_status != WATCHER_GIT_OK && cdup_status != WATCHER_GIT_COMMAND_FAILED) {
            s->baseline_done = false;
            return false;
        }
        watcher_git_status_t head_status = git_head(w, s, s->last_head, sizeof(s->last_head));
        if (head_status != WATCHER_GIT_OK && head_status != WATCHER_GIT_COMMAND_FAILED) {
            s->baseline_done = false;
            return false;
        }
        /* last_dirty_sig stays 0 ("clean known"): a tree that is ALREADY
         * dirty at baseline reindexes once on the first poll — the watcher
         * cannot know whether that state made it into the DB (e.g. server
         * restart with a stale artifact). At-least-once, then the signature
         * gates further polls (#937). */
        int file_count = 0;