feat(p4): replace git-p4 wrapper with clj-p4 (cold turkey)

Delete git.clj:471-592 (the entire ;; --- Perforce via git-p4 ---
block) and replace with src/noumenon/p4.clj — a thin adapter over
the new pure-Clojure clj-p4 library. clj-p4 sits at ../clj-p4
via :local/root in deps.edn until v0.1.0 ships to Clojars.

Touchpoints swapped to noumenon.p4: repo.clj/clone-or-reuse-p4,
repo_manager.clj/url->db-name + register-repo! + refresh-repo!,
sync.clj/branch-vcs + auto-sync-p4!. mcp.clj's noumenon_update
description updated to mention Perforce streams.

Behaviour change worth flagging for early-alpha users (none known
yet): clj-p4 produces *bare* git repos rather than non-bare working
trees. data/repos/<name>/HEAD now exists where data/repos/<name>/.git/
used to. Re-clone any pre-existing P4 imports to migrate.

Tests: noumenon.p4-test covers depot-path detection, clone-name
derivation, and validate-throws semantics. The lower-level
parsing/clone/sync correctness lives in clj-p4's own suite (200
assertions there). All 630 noumenon tests pass.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: leifericf

deps.edn

@@ -8,7 +8,8 @@
   http-kit/http-kit        {:mvn/version "2.8.0"}
   org.clojure/tools.namespace {:mvn/version "1.5.0"}
   com.taoensso/nippy          {:mvn/version "3.4.2"}
-  integrant/integrant         {:mvn/version "0.13.1"}}
+  integrant/integrant         {:mvn/version "0.13.1"}
+  io.github.leifericf/clj-p4  {:local/root "../clj-p4"}}
 
  :aliases
  {:test

src/noumenon/git.clj

@@ -1,6 +1,5 @@
 (ns noumenon.git
-  (:require [clojure.edn :as edn]
-            [clojure.java.io :as io]
+  (:require [clojure.java.io :as io]
             [clojure.java.shell :as shell]
             [clojure.string :as str]
             [datomic.client.api :as d]
@@ -91,7 +90,7 @@
    regex-based hostname extractor returns nil for those, so its
    `when-let` would otherwise short-circuit and leave the URL
    unchecked. Perforce depot paths follow a different code path
-   (`p4-clone!`) and never reach this validator.
+   (`noumenon.p4/clone!`) and never reach this validator.
 
    Both throws carry `:status 400` so HTTP handlers render bad URLs as
    400, not as the route handler's default 500 fallback."
@@ -467,126 +466,3 @@
        {:commits-imported (count to-import)
         :commits-skipped  skipped
         :elapsed-ms       elapsed}))))
-
-;; --- Perforce via git-p4 ---
-
-(defn p4-depot-path?
-  "True if s looks like a Perforce depot path (starts with //)."
-  [s]
-  (boolean (and (string? s) (str/starts-with? s "//"))))
-
-(defn p4-available?
-  "True if git-p4 is available (git p4 subcommand works)."
-  []
-  (zero? (:exit (shell/sh "git" "p4" "--help"))))
-
-(defn p4-clone?
-  "True if repo-path is a git-p4 clone (has p4 remote refs)."
-  [repo-path]
-  (let [p4-refs (io/file repo-path ".git" "refs" "remotes" "p4")]
-    (and (.isDirectory p4-refs)
-         (pos? (count (.list p4-refs))))))
-
-(defn p4-depot->clone-name
-  "Derive a local clone directory name from a depot path.
-   //depot/ProjectA/main/... -> ProjectA-main
-   //stream/main/...         -> main
-   //depot/...               -> depot"
-  [depot-path]
-  (let [segments (-> depot-path
-                     (str/replace #"^//" "")
-                     (str/replace #"/\.\.\.$" "")
-                     (str/replace #"/$" "")
-                     (str/split #"/"))
-        ;; Use sub-path segments if available, else fall back to depot name
-        name-parts (if (> (count segments) 1) (rest segments) segments)]
-    (-> (str/join "-" name-parts)
-        (str/replace #"[^a-zA-Z0-9\-_.]" ""))))
-
-(defn p4-clone-path
-  "Local clone path for a depot path: data/repos/<derived-name>."
-  [depot-path]
-  (str "data/repos/" (p4-depot->clone-name depot-path)))
-
-(def ^:private default-p4-excludes
-  "Default binary exclusion patterns, loaded from p4-excludes.edn."
-  (delay
-    (some-> (io/resource "p4-excludes.edn") slurp edn/read-string)))
-
-(defn p4-exclude-patterns
-  "Compute the final exclusion pattern list given options.
-   Options:
-     :no-default-excludes?  — skip default patterns (default false)
-     :extra-excludes        — additional patterns to exclude (vector of strings)
-     :includes              — patterns to remove from excludes (vector of strings)"
-  [{:keys [no-default-excludes? extra-excludes includes]}]
-  (let [defaults (when-not no-default-excludes?
-                   (->> (vals @default-p4-excludes) (apply concat)))
-        all      (concat defaults extra-excludes)
-        include-set (set includes)]
-    (->> all (remove include-set) distinct vec)))
-
-(defn- p4-exclude-args
-  "Build -/ arguments for git p4 clone from a list of exclusion patterns."
-  [patterns]
-  (mapcat (fn [p] ["-/" p]) patterns))
-
-(defn validate-p4-depot-path!
-  "Validate a Perforce depot path. Must start with //, contain only safe chars,
-   and have at least one depot name segment. Throws on invalid input."
-  [depot-path]
-  (when-not (and (string? depot-path)
-                 (re-matches #"//[a-zA-Z0-9_\-./]+" depot-path)
-                 (not (str/includes? depot-path "..")))
-    (throw (ex-info "Invalid Perforce depot path"
-                    {:depot-path depot-path
-                     :message "Depot path must start with // and contain only alphanumeric, dash, underscore, dot, or slash characters"})))
-  (when-not (p4-available?)
-    (throw (ex-info "git-p4 is not available. Install git-p4 to use Perforce support."
-                    {:depot-path depot-path}))))
-
-(defn p4-clone!
-  "Clone a Perforce depot path via git-p4 into target-dir.
-   Options:
-     :excludes             — override exclusion patterns (vector of strings)
-     :no-default-excludes? — skip default binary excludes
-     :extra-excludes       — additional patterns to exclude
-     :includes             — patterns to remove from default excludes
-     :use-client-spec?     — use P4 workspace view for filtering
-     :max-changes          — limit history depth (number of changelists)"
-  [depot-path target-dir opts]
-  (validate-p4-depot-path! depot-path)
-  (let [excludes   (or (:excludes opts)
-                       (p4-exclude-patterns opts))
-        args       (cond-> ["git" "p4" "clone"]
-                     (:use-client-spec? opts) (conj "--use-client-spec")
-                     (not (:use-client-spec? opts)) (into (p4-exclude-args excludes))
-                     (:max-changes opts) (conj (str "--max-changes=" (:max-changes opts)))
-                     true (conj (str depot-path "@all"))
-                     true (conj "--destination" (str target-dir)))
-        _          (log! (str "git-p4: cloning " depot-path " into " target-dir
-                              " (" (count excludes) " exclusion patterns)"))
-        {:keys [exit err]} (apply shell/sh args)]
-    (when-not (zero? exit)
-      (throw (ex-info (str "git p4 clone failed: " (str/trim (or err "")))
-                      {:exit exit :depot-path depot-path :target target-dir
-                       :stderr (when err (subs err 0 (min (count err) 500)))})))
-    (log! "git-p4: clone complete")
-    target-dir))
-
-(defn p4-sync!
-  "Sync a git-p4 clone with latest Perforce changelists.
-   Runs `git p4 sync` then `git p4 rebase`."
-  [repo-path]
-  (let [sync-args ["-C" (str repo-path) "p4" "sync"]
-        {:keys [exit err]} (apply shell/sh "git" sync-args)]
-    (when-not (zero? exit)
-      (throw (ex-info (str "git p4 sync failed: " (str/trim (or err "")))
-                      {:exit exit :repo-path (str repo-path)}))))
-  (let [rebase-args ["-C" (str repo-path) "p4" "rebase"]
-        {:keys [exit err]} (apply shell/sh "git" rebase-args)]
-    (when-not (zero? exit)
-      (throw (ex-info (str "git p4 rebase failed: " (str/trim (or err "")))
-                      {:exit exit :repo-path (str repo-path)}))))
-  (log! (str "git-p4: synced " repo-path))
-  true)

src/noumenon/mcp.clj

@@ -62,7 +62,7 @@
                   :properties repo-path-prop
                   :required ["repo_path"]}}
    {:name "noumenon_update"
-    :description "Update the knowledge graph with latest changes. Runs import + enrich for changed files. For git-p4 clones, automatically syncs from Perforce first. Fast and cheap (no LLM calls by default). Pass analyze=true to also re-analyze changed files with LLM. Works as a first-time setup too — if no database exists, runs the full pipeline."
+    :description "Update the knowledge graph with latest changes. Runs import + enrich for changed files. For Perforce-stream clones (made via clj-p4), automatically syncs from Perforce first. Fast and cheap (no LLM calls by default). Pass analyze=true to also re-analyze changed files with LLM. Works as a first-time setup too — if no database exists, runs the full pipeline."
     :inputSchema {:type "object"
                   :properties (merge repo-path-prop
                                      {"analyze" {:type "boolean"

src/noumenon/p4.clj

@@ -0,0 +1,122 @@
+(ns noumenon.p4
+  "Adapter from Noumenon to clj-p4. The single point of integration with
+   the pure-Clojure Perforce-to-Git library; everywhere else in the code
+   talks to this namespace, not to clj-p4 directly.
+
+   Connection details (`P4PORT`, `P4USER`, `P4CLIENT`, `P4PASSWD`,
+   `P4CHARSET`) come from the environment, just like the historical
+   git-p4 wrapper. Clones are bare; sync derives the stream from the most
+   recent commit's `git-p4:` trailer."
+  (:require [clj-p4.api :as api]
+            [clj-p4.exclude :as p4-exclude]
+            [clj-p4.spec :as p4-spec]
+            [clojure.edn :as edn]
+            [clojure.java.io :as io]
+            [clojure.string :as str]
+            [noumenon.util :refer [log!]]))
+
+(def ^:private excludes-resource
+  (delay (some-> (io/resource "p4-excludes.edn") slurp edn/read-string)))
+
+(defn depot-path?
+  "True if `s` looks like a Perforce depot path."
+  [s]
+  (p4-spec/depot-path? s))
+
+(defn validate-depot-path!
+  "Throws on invalid depot paths; returns the path otherwise."
+  [s]
+  (p4-spec/validate-depot-path! s))
+
+(defn available?
+  "True if the `p4` CLI is on PATH."
+  []
+  (api/available?))
+
+(defn clone?
+  "True if `repo-path` is a clj-p4 (or legacy git-p4) clone — has a commit
+   on `refs/heads/main` whose message contains the `git-p4:` trailer."
+  [repo-path]
+  (api/clone? repo-path))
+
+(defn depot->clone-name
+  "Derive a local clone directory name from a depot path.
+     //depot/ProjectA/main/... → ProjectA-main
+     //stream/main/...         → main"
+  [depot-path]
+  (let [{:depot/keys [depot segments]} (p4-spec/parse-depot-path depot-path)
+        parts (if (seq segments) segments [depot])]
+    (-> (str/join "-" parts)
+        (str/replace #"[^a-zA-Z0-9\-_.]" ""))))
+
+(defn clone-path
+  "Local clone path for a depot path: `data/repos/<derived-name>`."
+  [depot-path]
+  (str "data/repos/" (depot->clone-name depot-path)))
+
+(defn- conn-from-env []
+  (cond-> {:p4/port (or (System/getenv "P4PORT") "perforce:1666")}
+    (System/getenv "P4USER")    (assoc :p4/user    (System/getenv "P4USER"))
+    (System/getenv "P4CLIENT")  (assoc :p4/client  (System/getenv "P4CLIENT"))
+    (System/getenv "P4CHARSET") (assoc :p4/charset (keyword (System/getenv "P4CHARSET")))
+    (System/getenv "P4PASSWD")  (assoc :p4/ticket  (System/getenv "P4PASSWD"))))
+
+(defn- progress-fn [op]
+  (when (= :process-change (:op/kind op))
+    (log! (str "p4 change " (:op/change op)))))
+
+(defn- compile-excludes [opts]
+  (let [patterns (p4-exclude/exclude-patterns
+                  (assoc opts :resource @excludes-resource))]
+    (p4-exclude/compile-patterns patterns)))
+
+(defn clone!
+  "Clone a Perforce stream into `target-dir` as a bare git repo. Options:
+     :no-default-excludes?  skip the `p4-excludes.edn` resource defaults.
+     :extra-excludes        additional patterns to exclude.
+     :includes              patterns to remove from the union (whitelist).
+     :max-changes           cap on imported changelists."
+  [depot-path target-dir opts]
+  (validate-depot-path! depot-path)
+  (log! (str "clj-p4: cloning " depot-path " into " target-dir))
+  (api/clone! {:conn        (conn-from-env)
+               :stream      depot-path
+               :target      (str target-dir)
+               :exclude     (compile-excludes (or opts {}))
+               :max-changes (:max-changes opts)
+               :progress-fn progress-fn})
+  (log! "clj-p4: clone complete")
+  (str target-dir))
+
+(defn- last-commit-message [repo-path]
+  (try
+    (-> (clj-p4.shell.proc/run-checked!
+         ["git" "-C" (str repo-path) "log" "-1" "--pretty=%B"
+          "refs/heads/main"])
+        :stdout-bytes
+        (String. "UTF-8"))
+    (catch Exception _ nil)))
+
+(defn- stream-from-trailer
+  "Extract the stream depot-path from a `git-p4:` commit trailer."
+  [msg]
+  (when msg
+    (when-let [[_ s] (re-find #"depot-paths\s*=\s*\"([^\"]+?)/?\"" msg)]
+      s)))
+
+(defn sync!
+  "Bring an existing clj-p4 clone at `repo-path` up to date with Perforce.
+   Derives the stream from the most recent commit's `git-p4:` trailer."
+  [repo-path]
+  (let [stream (-> (last-commit-message repo-path) stream-from-trailer)]
+    (when-not stream
+      (throw (ex-info (str "Cannot determine Perforce stream for "
+                           repo-path " — re-clone needed")
+                      {:repo-path (str repo-path)})))
+    (log! (str "clj-p4: syncing " repo-path " from " stream))
+    (api/sync! {:conn        (conn-from-env)
+                :stream      stream
+                :target      (str repo-path)
+                :progress-fn progress-fn})
+    (log! "clj-p4: sync complete")
+    true))

src/noumenon/repo.clj

@@ -6,6 +6,7 @@
             [datomic.client.api :as d]
             [noumenon.db :as db]
             [noumenon.git :as git]
+            [noumenon.p4 :as p4]
             [noumenon.util :as util :refer [log!]]))
 
 (defn- clone-or-reuse
@@ -27,13 +28,14 @@
       (.getCanonicalPath f))))
 
 (defn- clone-or-reuse-p4
-  "Clone a Perforce depot path via git-p4, or reuse an existing clone."
+  "Clone a Perforce stream via clj-p4 as a bare repo, or reuse the existing
+   clone. Bare-repo presence is detected by the `HEAD` file at the target."
   [depot-path opts]
-  (let [target (git/p4-clone-path depot-path)]
-    (if (.isDirectory (io/file target ".git"))
-      (do (log! (str "Using existing git-p4 clone at " target)) target)
-      (do (log! (str "Cloning P4 depot " depot-path " into " target " ..."))
-          (git/p4-clone! depot-path target opts)
+  (let [target (p4/clone-path depot-path)]
+    (if (.isFile (io/file target "HEAD"))
+      (do (log! (str "Using existing clj-p4 clone at " target)) target)
+      (do (log! (str "Cloning P4 stream " depot-path " into " target " ..."))
+          (p4/clone! depot-path target opts)
           target))))
 
 (defn resolve-repo
@@ -42,11 +44,11 @@
    Options:
      :lookup-uri-fn  — (fn [db-dir db-name]) → stored :repo/uri or nil
      :db-dir         — database storage directory
-     :p4-opts        — options for git-p4 clone (excludes, use-client-spec?, etc.)"
+     :p4-opts        — options for clj-p4 clone (excludes, max-changes, etc.)"
   [identifier db-dir {:keys [lookup-uri-fn p4-opts]}]
   (cond
-    ;; Perforce depot path — clone via git-p4 and use local path
-    (git/p4-depot-path? identifier)
+    ;; Perforce depot path — clone via clj-p4 and use local path
+    (p4/depot-path? identifier)
     (let [local (clone-or-reuse-p4 identifier (or p4-opts {}))]
       {:repo-path (.getCanonicalPath (io/file local))
        :db-name   (util/derive-db-name local)})

src/noumenon/repo_manager.clj

@@ -6,6 +6,7 @@
             [datomic.client.api :as d]
             [noumenon.db :as db]
             [noumenon.git :as git]
+            [noumenon.p4 :as p4]
             [noumenon.sync :as sync]
             [noumenon.util :as util :refer [log!]]))
 
@@ -30,8 +31,8 @@
    git@github.com:anthropics/claude-code.git -> anthropics-claude-code
    //depot/ProjectA/main/... -> ProjectA-main"
   [url]
-  (let [name (if (git/p4-depot-path? url)
-               (git/p4-depot->clone-name url)
+  (let [name (if (p4/depot-path? url)
+               (p4/depot->clone-name url)
                (let [cleaned (-> url (str/replace #"\.git$" "") (str/replace #"/$" ""))
                      parts   (str/split cleaned #"[/:]")
                      segments (take-last 2 parts)
@@ -64,7 +65,7 @@
    Returns {:db-name str :clone-path str :import-result map}."
   [meta-conn db-dir {:keys [url name branch p4-opts]}]
   (let [db-name    (or name (url->db-name url))
-        p4?        (git/p4-depot-path? url)
+        p4?        (p4/depot-path? url)
         clone-path (repo-clone-path db-dir db-name)
         clone-dir  (io/file clone-path)]
     ;; Prevent path traversal
@@ -77,7 +78,7 @@
       ;; with read access to the log.
       (log! (str "Cloning " url " into " db-name ".git ..."))
       (if p4?
-        (git/p4-clone! url clone-path (or p4-opts {}))
+        (p4/clone! url clone-path (or p4-opts {}))
         (git/clone-bare! url clone-path)))
     ;; Register in meta database
     (d/transact meta-conn
@@ -94,7 +95,7 @@
 
 (defn refresh-repo!
   "Fetch latest and run incremental import + enrich for a registered repo.
-   Detects git-p4 clones and uses p4-sync! instead of git fetch.
+   Detects clj-p4 clones and uses `noumenon.p4/sync!` instead of git fetch.
    Returns summary map."
   [db-dir db-name]
   (let [clone-path (repo-clone-path db-dir db-name)
@@ -105,8 +106,8 @@
       (throw (ex-info (str "Clone not found for " db-name)
                       {:db-name db-name :clone-path clone-path})))
     (log! (str "Fetching " db-name " ..."))
-    (if (git/p4-clone? clone-path)
-      (git/p4-sync! clone-path)
+    (if (p4/clone? clone-path)
+      (p4/sync! clone-path)
       (git/fetch! clone-path))
     (let [repo-uri (or (ffirst (d/q '[:find ?uri :where [_ :repo/uri ?uri]]
                                     (d/db conn)))