rzen/lanework
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Build HistoryStore — opt-in git and mode detection

Browse Source 
The pro-m1 foundation card. SwiftGitX 0.4.0 (bundled libgit2, the
pathfinder's pin) joins the one target; new Kanban/Git/ holds
BoardGitMode (pure nearest-.git-wins detection, .git-as-file counts,
NSString ancestor walk), HistoryStore (@MainActor @Observable;
compose() is the tier gate — free tier gets no object, no detection,
no stat), GitRepository (scope-confined SwiftGitX handles: create =
init + HEAD forced to main + whole-tree "Initial board state" commit;
branch reads incl. unborn/detached; path-history ranks), GitIdentity
(derived default as a pure function + repo-local config reader — not
libgit2's merged ladder), and GitPathHistory (Mutex-guarded lazy
ranker). beginSession composes the git state beside the tier and
feeds BoardStore.makeIdentityHistoryRanker; git-mode loads pass the
git-backed IdentityHistoryRanker to BoardLoader. The popover's git
slot resolves a pure five-way matrix: free tier unchanged (absent /
BoardGitNote), Pro mode-aware — Add Git on mode none, honest prose on
repo-nested, read-only branch line on git. Provider binding
unchanged: both tiers still bind native until the undo/redo card.

42 new tests across 8 suites, all repositories built through bundled
libgit2; InertGitTests untouched and green. 2194 tests / 375 suites.

Claude-Session: https://claude.ai/code/session_01SR4XGjmBE16ZUYWpfFHXwY
This commit is contained in:
rzen
2026-07-31 13:18:07 -04:00
parent 9f8eebe23b
commit 189af238a1
15 changed files with 1943 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Kanban/Git/GitIdentity.swift
+190
View File
@@ -0,0 +1,190 @@
import Foundation
// MARK: - GitIdentity
/// **Who the app's commits are authored by** (06-history-undo.md ▸ Interaction with external
/// writers ▸ "Where the user's git identity comes from").
///
/// Two sources, in the design's own order — and the order is git's own, which is the point:
///
/// 1. **Repo-local `.git/config` wins when present.** "Standard git semantics, readable in-sandbox
/// because it lives under the board root, and the natural state of adopted/cloned boards." The
/// popover's name/email fields (a later card) write exactly that file: "the setting *is* the
/// file, portable to any git client, per-board by nature".
/// 2. **Absent repo config, the derived default**: "the macOS account's full name plus
/// `shortname@hostname` — git's own no-config fallback shape, zero ceremony."
///
/// What is deliberately *not* a source is `~/.gitconfig`: the app is sandboxed and cannot read it,
/// which 06 states as an honest limit rather than a bug. Nothing here consults libgit2's own config
/// ladder for the same reason — a global layer that is unreachable in the shipped app but readable
/// on a developer's machine would make the app's authorship depend on how it was launched.
///
/// The commits this type does *not* speak for are the synthetic ones: foreign changes commit as
/// `Lanework External <external@lanework.invalid>` and `modified-by`-stamped windows as
/// `<slug>@agents.lanework.invalid` (06). Those are the auto-commit card's, and they are pinned
/// strings rather than derivations — nothing about them belongs in a type about *the user's*
/// identity.
public struct GitIdentity: Sendable, Equatable {
public let name: String
public let email: String
public init(name: String, email: String) {
self.name = name
self.email = email
}
}
// MARK: - The derived default
public extension GitIdentity {
/// The derived default, as a **pure function of three strings** — so the shape 06 names can be
/// proven without asserting anything about the machine the tests run on.
///
/// `fullName` is the account's display name (`NSFullUserName()`), `accountName` its short name
/// (`NSUserName()`), `hostName` the machine's (`ProcessInfo.hostName`). Every one of them can
/// come back empty or shaped in a way git would reject, so each is defended:
///
/// - An empty full name falls back to the account name — git does the same when GECOS is blank,
/// and a commit authored by `"" <me@mac>` is a commit no client renders sensibly.
/// - The email's local part and host are sanitized to what an address may contain: a signature
/// with a space or an angle bracket in it is not merely ugly, libgit2 refuses it outright and
/// the commit fails.
/// - An empty host reads `localhost`, which is what a machine with no name is.
static func derived(fullName: String, accountName: String, hostName: String) -> GitIdentity {
let account = accountName.trimmingCharacters(in: .whitespacesAndNewlines)
let trimmedName = fullName.trimmingCharacters(in: .whitespacesAndNewlines)
let name = trimmedName.isEmpty ? (account.isEmpty ? "Lanework" : account) : trimmedName
let localPart = addressComponent(account, fallback: "user")
// A trailing dot is legal in a fully-qualified name and useless in an address; `.local`
// hosts keep theirs, which is exactly what git's own fallback produces on a Mac.
let host = addressComponent(
hostName.trimmingCharacters(in: .whitespacesAndNewlines).hasSuffix(".")
? String(hostName.trimmingCharacters(in: .whitespacesAndNewlines).dropLast())
: hostName,
fallback: "localhost"
)
return GitIdentity(name: name, email: "\(localPart)@\(host)")
}
/// The derived default for *this* machine — the one impure call, kept to one line so everything
/// above it stays provable.
static func derivedDefault() -> GitIdentity {
derived(
fullName: NSFullUserName(),
accountName: NSUserName(),
hostName: ProcessInfo.processInfo.hostName
)
}
/// **The resolution 06 states**, per key rather than wholesale: a repo-local config naming only
/// `user.name` contributes exactly that and the email still derives — git resolves each key on
/// its own, and a half-configured repo is a real state (it is what a `git config user.email`
/// typo leaves behind).
static func resolve(repoLocal: (name: String?, email: String?), derived: GitIdentity) -> GitIdentity {
func configured(_ value: String?, or fallback: String) -> String {
guard let trimmed = value?.trimmingCharacters(in: .whitespacesAndNewlines),
!trimmed.isEmpty else { return fallback }
return trimmed
}
return GitIdentity(
name: configured(repoLocal.name, or: derived.name),
email: configured(repoLocal.email, or: derived.email)
)
}
/// Characters an address part may carry, with everything else collapsed to `-`. Deliberately
/// conservative rather than RFC-complete: the input is a Mac account name and a Bonjour host
/// name, and the only job is that libgit2 accepts the signature and a git client renders it.
private static func addressComponent(_ raw: String, fallback: String) -> String {
let allowed = CharacterSet.alphanumerics.union(CharacterSet(charactersIn: "-._"))
let mapped = String(
String.UnicodeScalarView(
raw.unicodeScalars.map { allowed.contains($0) ? $0 : Unicode.Scalar("-") }
)
)
let trimmed = mapped.trimmingCharacters(in: CharacterSet(charactersIn: "-."))
return trimmed.isEmpty ? fallback : trimmed
}
}
// MARK: - Repo-local config
/// **The board's own `.git/config`, read as text** (06-history-undo.md: "repo-local `.git/config`
/// wins when present … readable in-sandbox because it lives under the board root").
///
/// Read by hand rather than through libgit2's config ladder, deliberately: `git_repository_config`
/// merges the repository, global and system layers, so a value read through it is not the answer to
/// "what does *this repository* say" — it is the answer to "what does this machine say", which is
/// the question the sandbox makes unanswerable and which 06 rules out of the identity story
/// entirely. Reading the file the design names gives the same answer in the shipped sandboxed app,
/// in a test, and on a developer's machine with a `~/.gitconfig` full of opinions.
///
/// The parse is tolerant by design: it is looking for two keys in one section of a format that
/// allows comments, indentation and quoting, and anything it fails to understand simply reads as
/// absent — which falls through to the derived default, the same place a missing file lands.
enum GitConfigFile {
/// `user.name` / `user.email` as the config file at `gitDirectory/config` states them; both
/// `nil` when the file does not exist, cannot be read, or names neither key.
static func identity(inGitDirectory gitDirectory: URL) -> (name: String?, email: String?) {
let configURL = gitDirectory.appendingPathComponent("config")
guard let text = try? String(contentsOf: configURL, encoding: .utf8) else { return (nil, nil) }
return identity(inConfigText: text)
}
/// The parse, over text — the pure half, and where the format's edges are decided.
static func identity(inConfigText text: String) -> (name: String?, email: String?) {
var section: String?
var name: String?
var email: String?
for rawLine in text.split(separator: "\n", omittingEmptySubsequences: false) {
let line = rawLine.trimmingCharacters(in: .whitespaces)
if line.isEmpty || line.hasPrefix("#") || line.hasPrefix(";") { continue }
if line.hasPrefix("[") {
// `[user]`, and `[user "work"]` — a subsection is somebody else's scope, so the
// header's first token is what names the section.
let header = line.drop(while: { $0 == "[" }).prefix(while: { $0 != "]" })
section = header
.split(separator: " ", maxSplits: 1)
.first
.map { $0.trimmingCharacters(in: .whitespaces).lowercased() }
continue
}
guard section == "user", let separator = line.firstIndex(of: "=") else { continue }
let key = line[line.startIndex..<separator].trimmingCharacters(in: .whitespaces).lowercased()
let value = unquoted(line[line.index(after: separator)...].trimmingCharacters(in: .whitespaces))
switch key {
case "name": name = value.nonEmpty
case "email": email = value.nonEmpty
default: continue
}
}
return (name, email)
}
/// Strips one layer of surrounding quotes, and an unquoted trailing comment. A `#` inside
/// quotes is content — git's own rule, and the one place a naive strip would corrupt a name.
private static func unquoted(_ value: String) -> String {
if value.hasPrefix("\"") {
let body = value.dropFirst()
guard let closing = body.firstIndex(of: "\"") else { return String(body) }
return String(body[body.startIndex..<closing])
}
let uncommented = value.prefix { $0 != "#" && $0 != ";" }
return uncommented.trimmingCharacters(in: .whitespaces)
}
}
// MARK: - String conveniences
private extension String {
var nonEmpty: String? { isEmpty ? nil : self }
}