@pi-chamber/web 0.1.8

package/server/lib/fs/search.js

@@ -0,0 +1,238 @@
+const FILE_SEARCH_MAX_CONCURRENCY = 5;
+const FILE_SEARCH_EXCLUDED_DIRS = new Set([
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  '.next',
+  '.turbo',
+  '.cache',
+  'coverage',
+  'tmp',
+  'logs',
+]);
+
+const normalizeRelativeSearchPath = (rootPath, targetPath, path) => {
+  const relative = path.relative(rootPath, targetPath) || path.basename(targetPath);
+  return relative.split(path.sep).join('/') || targetPath;
+};
+
+const shouldSkipSearchDirectory = (name, includeHidden) => {
+  if (!name) {
+    return false;
+  }
+  if (!includeHidden && name.startsWith('.')) {
+    return true;
+  }
+  return FILE_SEARCH_EXCLUDED_DIRS.has(name.toLowerCase());
+};
+
+const listDirectoryEntries = async (dirPath, fsPromises) => {
+  try {
+    return await fsPromises.readdir(dirPath, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+};
+
+const fuzzyMatchScoreNormalized = (normalizedQuery, candidate) => {
+  if (!normalizedQuery) return 0;
+
+  const q = normalizedQuery;
+  const c = candidate.toLowerCase();
+  if (c.includes(q)) {
+    const idx = c.indexOf(q);
+    let bonus = 0;
+    if (idx === 0) {
+      bonus = 20;
+    } else {
+      const prev = c[idx - 1];
+      if (prev === '/' || prev === '_' || prev === '-' || prev === '.' || prev === ' ') {
+        bonus = 15;
+      }
+    }
+    return 100 + bonus - Math.min(idx, 20) - Math.floor(c.length / 5);
+  }
+
+  let score = 0;
+  let lastIndex = -1;
+  let consecutive = 0;
+
+  for (let i = 0; i < q.length; i += 1) {
+    const ch = q[i];
+    if (!ch || ch === ' ') continue;
+
+    const idx = c.indexOf(ch, lastIndex + 1);
+    if (idx === -1) {
+      return null;
+    }
+
+    const gap = idx - lastIndex - 1;
+    if (gap === 0) {
+      consecutive += 1;
+    } else {
+      consecutive = 0;
+    }
+
+    score += 10;
+    score += Math.max(0, 18 - idx);
+    score -= Math.min(gap, 10);
+
+    if (idx === 0) {
+      score += 12;
+    } else {
+      const prev = c[idx - 1];
+      if (prev === '/' || prev === '_' || prev === '-' || prev === '.' || prev === ' ') {
+        score += 10;
+      }
+    }
+
+    score += consecutive > 0 ? 12 : 0;
+    lastIndex = idx;
+  }
+
+  score += Math.max(0, 24 - Math.floor(c.length / 3));
+  return score;
+};
+
+export const createFsSearchRuntime = ({ fsPromises, path, spawn, resolveGitBinaryForSpawn }) => {
+  const searchFilesystemFiles = async (rootPath, options) => {
+    const { limit, query, includeHidden, respectGitignore } = options;
+    const includeHiddenEntries = Boolean(includeHidden);
+    const normalizedQuery = query.trim().toLowerCase();
+    const matchAll = normalizedQuery.length === 0;
+    const queue = [rootPath];
+    const visited = new Set([rootPath]);
+    const shouldRespectGitignore = respectGitignore !== false;
+    const collectLimit = matchAll ? limit : Math.max(limit * 3, 200);
+    const candidates = [];
+
+    while (queue.length > 0 && candidates.length < collectLimit) {
+      const batch = queue.splice(0, FILE_SEARCH_MAX_CONCURRENCY);
+
+      const dirResults = await Promise.all(
+        batch.map(async (dir) => {
+          if (!shouldRespectGitignore) {
+            return { dir, dirents: await listDirectoryEntries(dir, fsPromises), ignoredPaths: new Set() };
+          }
+
+          try {
+            const dirents = await listDirectoryEntries(dir, fsPromises);
+            const pathsToCheck = dirents.map((dirent) => dirent.name).filter(Boolean);
+            if (pathsToCheck.length === 0) {
+              return { dir, dirents, ignoredPaths: new Set() };
+            }
+
+            const result = await new Promise((resolve) => {
+              const child = spawn(resolveGitBinaryForSpawn(), ['check-ignore', '--', ...pathsToCheck], {
+                cwd: dir,
+                windowsHide: true,
+                stdio: ['ignore', 'pipe', 'pipe'],
+              });
+
+              let stdout = '';
+              child.stdout.on('data', (data) => { stdout += data.toString(); });
+              child.on('close', () => resolve(stdout));
+              child.on('error', () => resolve(''));
+            });
+
+            const ignoredNames = new Set(
+              String(result)
+                .split('\n')
+                .map((name) => name.trim())
+                .filter(Boolean)
+            );
+
+            return { dir, dirents, ignoredPaths: ignoredNames };
+          } catch {
+            return { dir, dirents: await listDirectoryEntries(dir, fsPromises), ignoredPaths: new Set() };
+          }
+        })
+      );
+
+      for (const { dir: currentDir, dirents, ignoredPaths } of dirResults) {
+        for (const dirent of dirents) {
+          const entryName = dirent.name;
+          if (!entryName || (!includeHiddenEntries && entryName.startsWith('.'))) {
+            continue;
+          }
+
+          if (shouldRespectGitignore && ignoredPaths.has(entryName)) {
+            continue;
+          }
+
+          const entryPath = path.join(currentDir, entryName);
+
+          if (dirent.isDirectory()) {
+            if (shouldSkipSearchDirectory(entryName, includeHiddenEntries)) {
+              continue;
+            }
+            if (!visited.has(entryPath)) {
+              visited.add(entryPath);
+              queue.push(entryPath);
+            }
+            continue;
+          }
+
+          if (!dirent.isFile()) {
+            continue;
+          }
+
+          const relativePath = normalizeRelativeSearchPath(rootPath, entryPath, path);
+          const extension = entryName.includes('.') ? entryName.split('.').pop()?.toLowerCase() : undefined;
+
+          if (matchAll) {
+            candidates.push({
+              name: entryName,
+              path: entryPath,
+              relativePath,
+              extension,
+              score: 0,
+            });
+          } else {
+            const score = fuzzyMatchScoreNormalized(normalizedQuery, relativePath);
+            if (score !== null) {
+              candidates.push({
+                name: entryName,
+                path: entryPath,
+                relativePath,
+                extension,
+                score,
+              });
+            }
+          }
+
+          if (candidates.length >= collectLimit) {
+            queue.length = 0;
+            break;
+          }
+        }
+
+        if (candidates.length >= collectLimit) {
+          break;
+        }
+      }
+    }
+
+    if (!matchAll) {
+      candidates.sort((a, b) => {
+        if (b.score !== a.score) return b.score - a.score;
+        if (a.relativePath.length !== b.relativePath.length) {
+          return a.relativePath.length - b.relativePath.length;
+        }
+        return a.relativePath.localeCompare(b.relativePath);
+      });
+    }
+
+    return candidates.slice(0, limit).map(({ name, path: filePath, relativePath, extension }) => ({
+      name,
+      path: filePath,
+      relativePath,
+      extension,
+    }));
+  };
+
+  return {
+    searchFilesystemFiles,
+  };
+};

package/server/lib/git/DOCUMENTATION.md

@@ -0,0 +1,180 @@
+# Git Module Documentation
+
+## Purpose
+This module provides Git repository operations for the web server runtime, including repository management, branch/worktree operations, status/diff queries, commit handling, and merge/rebase workflows.
+
+## Entrypoints and structure
+- `packages/web/server/lib/git/`: Git module directory containing all Git-related functionality.
+  - `index.js`: Public API entry point imported by `packages/web/server/index.js`.
+  - `routes.js`: Express route registration for `/api/git/*` endpoints.
+  - `service.js`: Core Git operations (repository, branch, worktree, commit, merge/rebase, status/diff, log).
+  - `credentials.js`: Git credentials management.
+  - `identity-storage.js`: Git identity (user.name, user.email) storage.
+
+## Public API
+
+The following functions are exported and used by the web server:
+
+### Repository Operations
+- `isGitRepository(directory)`: Check if a directory is a Git repository.
+- `getGlobalIdentity()`: Get global Git user.name, user.email, and core.sshCommand.
+- `getCurrentIdentity(directory)`: Get local Git identity (fallback to global if not set locally).
+- `hasLocalIdentity(directory)`: Check if local Git identity is configured.
+- `setLocalIdentity(directory, profile)`: Set local Git identity (userName, userEmail, authType, sshKey/host).
+- `getRemoteUrl(directory, remoteName)`: Get URL for a specific remote.
+
+### Status and Diff Operations
+- `getStatus(directory)`: Get comprehensive Git status including current branch, tracking, ahead/behind, file changes, diff stats, merge/rebase state.
+- `getDiff(directory, { path, staged, contextLines })`: Get diff output for files or entire working tree. Untracked symbolic links are represented as link entries without following their targets.
+- `getRangeDiff(directory, { base, head, path, contextLines })`: Get diff between two refs. Uses three-dot `base...head` semantics, so work merged into `head` from `base` is excluded and only the branch's own changes are returned. Prefers `origin/<base>` when that remote-tracking ref exists, so a stale local base branch does not resurface already-merged commits. Exposed as `GET /api/git/range-diff` (`path` optional; omit it for the whole range).
+- `getFileDiff(directory, { path, staged })`: Get original and modified file contents for a single file (handles images as data URLs and symbolic links as their link-target text).
+- `revertFile(directory, filePath, options)`: Revert a file. Default scope `all` discards staged and working-tree changes; scope `working` discards only unstaged/working-tree changes.
+- `stageFile(directory, filePath)`: Add one file path to the index.
+- `unstageFile(directory, filePath)`: Remove one file path from the index while preserving working-tree content.
+- `applyHunk(directory, filePath, options)`: Apply a single-hunk patch via `git apply`. `options.action` is `stage` (`git apply --cached`), `unstage` (`git apply --cached --reverse`), or `discard` (`git apply --reverse` in the working tree). The patch is written to a temp file; a `--check` runs first so a stale hunk fails with a clear "refresh and try again" error instead of a partial mutation. The patch target path must match the requested file.
+
+### Branch Operations
+- `getBranches(directory)`: Get list of local and remote branches (filtered to active remote branches).
+- `createBranch(directory, branchName, options)`: Create and checkout a new branch.
+- `checkoutBranch(directory, branchName)`: Checkout an existing branch.
+- `deleteBranch(directory, branch, options)`: Delete a branch (supports force flag).
+- `renameBranch(directory, oldName, newName)`: Rename a branch and preserve upstream tracking.
+- `getRemotes(directory)`: Get list of configured remotes. Non-repository directories return an empty list without logging an operational failure.
+
+### Worktree Operations
+- `getWorktrees(directory)`: List all git worktrees for a repository.
+- `validateWorktreeCreate(directory, input)`: Validate worktree creation parameters (mode, branchName, startRef, upstream config).
+- `createWorktree(directory, input)`: Create a new worktree (supports 'new' and 'existing' modes, upstream setup). After populating the worktree, the repository's `post-checkout` hook runs once with git's standard arguments (null ref as previous HEAD, the checked-out HEAD, and flag `1`) from the worktree directory, mirroring `git worktree add` without `--no-checkout`; a missing or non-executable hook is skipped and a failing hook is logged as a warning, never failing worktree creation or the session bootstrap.
+- `removeWorktree(directory, input)`: Remove a worktree (optionally delete local branch).
+- `isLinkedWorktree(directory)`: Check if directory is a linked worktree (not primary).
+
+### Commit and Remote Operations
+- `commit(directory, message, options)`: Create a commit from the current index. `options.stageFiles` may be provided with `options.files` by older callers to stage only selected unstaged rows before committing, but the shared Git panel now stages/unstages explicitly before commit.
+- `pull(directory, options)`: Pull changes from remote.
+- `push(directory, options)`: Push changes to remote (auto-sets upstream if needed).
+- `fetch(directory, options)`: Fetch changes from remote.
+- `removeRemote(directory, options)`: Remove a configured remote (except `origin`).
+- `deleteRemoteBranch(directory, options)`: Delete a remote branch.
+
+### Log Operations
+- `getLog(directory, options)`: Get commit history with stats (supports maxCount, from, to, file filters).
+- `getCommitFiles(directory, commitHash)`: Get file changes for a specific commit.
+- `getCommitFileDiff(directory, hash, filePath, isBinary)`: Get before/after content for a specific file in a commit. Returns `{ original, modified, isBinary }`. Runs `git show <hash>^:<path>` and `git show <hash>:<path>` in parallel; returns empty strings on failure (added/deleted/root-commit edge cases).
+
+### Merge and Rebase Operations
+- `rebase(directory, options)`: Start a rebase onto a target branch.
+- `abortRebase(directory)`: Abort an in-progress rebase.
+- `continueRebase(directory)`: Continue a rebase after conflict resolution.
+- `merge(directory, options)`: Merge a branch into current branch.
+- `abortMerge(directory)`: Abort an in-progress merge.
+- `continueMerge(directory)`: Continue a merge after conflict resolution.
+- `getConflictDetails(directory)`: Get detailed conflict information including operation type, unmerged files, and diff.
+
+### Stash Operations
+- `listStashes(directory)`: List stash entries with ref, message, relative time, and hash.
+- `countStashFiles(directory, refs)`: Batch-count changed files for stash refs with bounded concurrency.
+- `stashPush(directory, options)`: Stash changes, always including untracked files, with optional message.
+- `stashApply(directory, options)`: Apply a stash by ref without removing it.
+- `stashPop(directory, options)`: Apply a stash by ref and drop it only after a successful apply.
+- `stashDrop(directory, options)`: Drop a stash by ref.
+
+## Internal Helpers
+
+The following functions are internal helpers used by exported functions:
+- `buildSshCommand(sshKeyPath)`: Build SSH command string for git config.
+- `buildGitEnv()`: Build Git environment with SSH_AUTH_SOCK resolution.
+- `createGit(directory)`: Create simple-git instance with environment.
+- `normalizeDirectoryPath(value)`: Normalize directory paths (supports ~ expansion).
+- `cleanBranchName(branch)`: Remove refs/heads/ or refs/ prefixes.
+- `parseWorktreePorcelain(raw)`: Parse `git worktree list --porcelain` output.
+- `resolveWorktreeProjectContext(directory)`: Resolve project context (projectID, primaryWorktree, worktreeRoot).
+- `resolveCandidateDirectory(...)`: Generate unique worktree directory candidates.
+- `resolveBranchForExistingMode(...)`: Resolve branch for existing-mode worktree creation.
+- `applyUpstreamConfiguration(...)`: Set upstream tracking for new branches.
+- `runPostCheckoutHook(directory)`: Invoke the worktree's `post-checkout` hook after population, because `git worktree add --no-checkout` and the bootstrap's `git reset --hard` never run git hooks. Runs with git's standard arguments and the worktree as cwd; skips missing/non-executable hooks and never throws on hook failure.
+- And various other internal helpers for Git command execution and parsing.
+
+## Response Contracts
+
+### Status Response
+- `current`: Current branch name.
+- `tracking`: Upstream branch (e.g., 'origin/main').
+- `ahead`: Number of commits ahead of upstream.
+- `behind`: Number of commits behind upstream.
+- `upstreamComparison`: Optional comparison against `upstream/<current-branch>`, with `{ remote, branch, ahead, behind }`.
+- `files`: Array of file objects with `path`, `index`, `working_dir` status codes.
+- `isClean`: Boolean indicating if working tree is clean.
+- `diffStats`: Object mapping file paths to `{ insertions, deletions }`.
+- `mergeInProgress`: Object with `{ head, message }` if merge in progress.
+- `rebaseInProgress`: Object with `{ headName, onto }` if rebase in progress.
+
+### Branches Response
+- `all`: Local branches plus remote-tracking branches that still exist on their remote. A remote that fails to answer keeps its branches in the list: "we could not ask" must not be reported as "these branches are gone", because callers use this list to decide whether a base branch exists at all.
+- `current`: Current branch name.
+- `branches`: Per-branch detail keyed by branch name, as reported by `git branch`.
+- `defaultBranches`: Each remote's default branch, keyed by remote name. Read from the local `remotes/<name>/HEAD` symbolic ref; for a remote that has none — clone writes it, a hand-added remote may not — the remote itself is asked once with `ls-remote --symref`. A remote that answers neither is absent rather than guessed, and consumers fall back to conventional branch names. Omitted entirely by runtimes that do not provide this Git metadata.
+
+### Runtime availability of range diffs
+- `GET /api/git/range-diff` is served by the PiChamber web server, so it is available to web, desktop, and mobile clients. The shared `GitAPI.getGitRangeDiff` is therefore optional: web supplies the HTTP implementation, and VS Code does not implement it because the extension host serves Git through its own bridge rather than these routes. Features built on range diffs (currently the AI diff walkthrough) are not offered in VS Code.
+
+### Staged and unstaged change handling
+- `status.files` exposes both `index` and `working_dir` codes. Shared UI uses these as separate scopes: staged rows are derived from non-empty `index` statuses, while unstaged rows are derived from `working_dir` statuses and untracked files.
+- A file with both staged and unstaged changes can appear in both UI sections. Staged rows request diffs with `staged: true`; unstaged rows request normal working-tree diffs.
+- The shared Git panel exposes explicit staging actions. Unstaged rows use `stageFile`, staged rows use `unstageFile`, and commits operate on the current staged index.
+- `stageFiles` remains supported for callers that need to stage a selected unstaged subset as part of commit. In that mode the server temporarily unstages unrelated index entries, stages `stageFiles`, commits from the index, then restores temporarily unstaged entries.
+### Worktree Create/Remove Response
+- `head`: HEAD commit SHA.
+- `name`: Worktree name.
+- `branch`: Local branch name.
+- `path`: Absolute path to worktree directory.
+- `directoryCreated`: Present when create returned after the target directory exists while background Git/bootstrap work continues.
+- `bootstrapStatus`: Background setup state. The legacy `status` remains `pending`, `ready`, or `failed`, while `phase` reports `directory-created`, `git-ready`, or `setup-ready`. Fast create starts at `pending`/`directory-created`; population and upstream Git completion advances to `pending`/`git-ready` before setup/start scripts; completed setup is `ready`/`setup-ready`. A missing in-memory state falls back to `ready`/`setup-ready`; clients continue to accept legacy status responses that omit `phase`.
+- Fast-create background failures remove OpenCode sandbox metadata for directories that never became Git worktrees, and remove the pre-created directory only if it is still empty. User-created files are never recursively deleted by this cleanup.
+- Worktree removal waits for any active create/bootstrap task for that directory before deleting it, preventing a background Git or setup task from restoring removed state or racing filesystem cleanup.
+- Worktree bootstrap retries transient `index.lock` conflicts. If the lock remains byte-for-byte and metadata-identical across the retry window, it is treated as stale, removed, and population continues automatically; changing locks are left untouched and reported as failures.
+- Worktree population enables Git `core.longpaths` (local repo config plus `-c core.longpaths=true` on `git reset --hard`) so deeply nested checkouts under the managed data-dir worktree root do not fail on Windows MAX_PATH with "Filename too long". Path-component limits that the filesystem itself rejects still fail bootstrap, with a clearer path-length guidance message.
+
+### Log Response
+- `all`: Array of commit objects with hash, date, message, author info, stats.
+- `latest`: Latest commit object or null.
+- `total`: Total number of commits.
+
+## Notes for Contributors
+
+### Adding a New Git Operation
+1. Add the function to `packages/web/server/lib/git/service.js`.
+2. Export the function if it's part of the public API.
+3. Use `createGit(directory)` to get a simple-git instance with the correct environment. `directory` is required (`baseDir`); never omit it so commands cannot inherit `process.cwd()`.
+4. Use `runGitCommand(cwd, args)` for direct git command execution with better error handling.
+5. Use `runGitCommandOrThrow(cwd, args, fallbackMessage)` for commands that must succeed.
+6. Return consistent error messages; use `parseGitErrorText(error)` to extract meaningful git errors.
+7. Update this file with the new function in the appropriate API section.
+
+### SSH Key Handling
+- SSH keys are escaped and validated via `escapeSshKeyPath` to prevent command injection.
+- On Windows, paths are converted to MSYS format (`C:/path` → `/c/path`).
+- SSH_AUTH_SOCK is automatically resolved via `resolveSshAuthSock` (checks GPG agent, gpgconf).
+
+### Working directory (simple-git)
+- Repository operations always pass an explicit `baseDir` (the opened project/directory path) into simple-git. Omitting `baseDir` would default to `process.cwd()`, which breaks when the server was launched from a neutral directory (e.g. `$HOME`) while the opened project lives elsewhere.
+- Global identity reads use the user home directory as `baseDir` (they do not need a repository).
+- A `GitError` / non-repository result from status or check must not abort project/session enumeration: routes return a soft non-repo payload and log a warning.
+
+### Worktree Naming
+- Worktree names are slugified via `slugWorktreeName`.
+- Random names use adjectives/nouns from `OPENCODE_ADJECTIVES` and `OPENCODE_NOUNS` lists.
+- Branches created for new worktrees use `pichamber/<worktree-name>` pattern.
+
+### Cross-Platform Considerations
+- Use `normalizeDirectoryPath` for all directory inputs to handle `~` and path separators.
+- Use `canonicalPath` for path comparisons to handle case-insensitive filesystems (Windows).
+- Windows Git commands use MSYS/MinGW paths; avoid direct Windows paths in git commands.
+
+### Error Handling
+- All exported functions should throw errors with descriptive messages.
+- Use `console.error` for logging Git operation failures.
+- Return structured objects for operations that need partial success reporting (e.g., merge/rebase conflicts).
+
+### Testing
+- Run `bun run type-check`, `bun run lint`, and `bun run build` before finalizing changes.
+- Consider edge cases: non-Git directories, missing remotes, conflict states, concurrent worktree operations.

package/server/lib/git/credentials.js

@@ -0,0 +1,41 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const GIT_CREDENTIALS_PATH = path.join(os.homedir(), '.git-credentials');
+
+export function discoverGitCredentials() {
+  const credentials = [];
+
+  if (!fs.existsSync(GIT_CREDENTIALS_PATH)) {
+    return credentials;
+  }
+
+  try {
+    const content = fs.readFileSync(GIT_CREDENTIALS_PATH, 'utf8');
+    const lines = content.split('\n').filter(line => line.trim());
+
+    for (const line of lines) {
+      try {
+        const url = new URL(line.trim());
+        const hostname = url.hostname;
+        const pathname = url.pathname && url.pathname !== '/' ? url.pathname : '';
+        const host = hostname + pathname;
+        const username = url.username || '';
+
+        if (host && username) {
+          const exists = credentials.some(c => c.host === host && c.username === username);
+          if (!exists) {
+            credentials.push({ host, username });
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch (error) {
+    console.error('Failed to read .git-credentials:', error);
+  }
+
+  return credentials;
+}

package/server/lib/git/identity-storage.js

@@ -0,0 +1,113 @@
+import fs from 'fs';
+import path from 'path';
+
+import { resolvePiChamberDataPath } from '../pichamber-data-dir.js';
+
+const STORAGE_DIR = resolvePiChamberDataPath();
+const STORAGE_FILE = path.join(STORAGE_DIR, 'git-identities.json');
+
+function ensureStorageDir() {
+  if (!fs.existsSync(STORAGE_DIR)) {
+    fs.mkdirSync(STORAGE_DIR, { recursive: true });
+  }
+}
+
+export function loadProfiles() {
+  ensureStorageDir();
+
+  if (!fs.existsSync(STORAGE_FILE)) {
+    return { profiles: [] };
+  }
+
+  try {
+    const content = fs.readFileSync(STORAGE_FILE, 'utf8');
+    const data = JSON.parse(content);
+    return data;
+  } catch (error) {
+    console.error('Failed to load git identity profiles:', error);
+    return { profiles: [] };
+  }
+}
+
+export function saveProfiles(data) {
+  ensureStorageDir();
+
+  try {
+    fs.writeFileSync(STORAGE_FILE, JSON.stringify(data, null, 2), 'utf8');
+    return true;
+  } catch (error) {
+    console.error('Failed to save git identity profiles:', error);
+    throw error;
+  }
+}
+
+export function getProfiles() {
+  const data = loadProfiles();
+  return data.profiles || [];
+}
+
+export function getProfile(id) {
+  const profiles = getProfiles();
+  return profiles.find(p => p.id === id) || null;
+}
+
+export function createProfile(profileData) {
+  const profiles = getProfiles();
+
+  if (profiles.some(p => p.id === profileData.id)) {
+    throw new Error(`Profile with ID "${profileData.id}" already exists`);
+  }
+
+  if (!profileData.id || !profileData.userName || !profileData.userEmail) {
+    throw new Error('Profile must have id, userName, and userEmail');
+  }
+
+  const newProfile = {
+    id: profileData.id,
+    name: profileData.name || profileData.userName,
+    userName: profileData.userName,
+    userEmail: profileData.userEmail,
+    authType: profileData.authType || 'ssh',
+    sshKey: profileData.sshKey || null,
+    signCommits: profileData.signCommits,
+    signingKey: profileData.signingKey || null,
+    host: profileData.host || null,
+    color: profileData.color || 'keyword',
+    icon: profileData.icon || 'branch'
+  };
+
+  profiles.push(newProfile);
+  saveProfiles({ profiles });
+
+  return newProfile;
+}
+
+export function updateProfile(id, updates) {
+  const profiles = getProfiles();
+  const index = profiles.findIndex(p => p.id === id);
+
+  if (index === -1) {
+    throw new Error(`Profile with ID "${id}" not found`);
+  }
+
+  profiles[index] = {
+    ...profiles[index],
+    ...updates,
+    id: profiles[index].id
+  };
+
+  saveProfiles({ profiles });
+  return profiles[index];
+}
+
+export function deleteProfile(id) {
+  const profiles = getProfiles();
+  const filteredProfiles = profiles.filter(p => p.id !== id);
+
+  if (filteredProfiles.length === profiles.length) {
+    throw new Error(`Profile with ID "${id}" not found`);
+  }
+
+  saveProfiles({ profiles: filteredProfiles });
+  return true;
+}

package/server/lib/git/index.js

@@ -0,0 +1,6 @@
+// Git library public entrypoint
+// Re-exports all Git operations, credentials, and identity storage functions
+
+export * from './service.js';
+export * from './credentials.js';
+export * from './identity-storage.js';