git-daemon 0.1.8 → 0.1.9

package/README.md

@@ -8,6 +8,7 @@ Git Daemon is a local Node.js service that exposes a small, authenticated HTTP A
 ## What it does
 
 - Clone, fetch, list branches, and read Git status using your system Git credentials
+- Provide a status summary for UI badges/tooltips
 - Stream long-running job logs via Server-Sent Events (SSE)
 - Open a repo in the OS file browser, terminal, or VS Code (with approvals)
 - Install dependencies with safer defaults (`--ignore-scripts` by default)
@@ -24,7 +25,7 @@ Git Daemon is a local Node.js service that exposes a small, authenticated HTTP A
 ## Requirements
 
 - Node.js (for running the daemon)
-- Git (for clone/fetch/branches/status)
+- Git (for clone/fetch/branches/status/summary)
 - Optional: `code` CLI for VS Code, `pnpm`/`yarn` for dependency installs
 
 ## Install
@@ -161,6 +162,14 @@ curl -H "Origin: https://app.example.com" \
   "http://127.0.0.1:8790/v1/git/branches?repoPath=owner/repo"
 ```
 
+Status summary (UI-friendly):
+
+```bash
+curl -H "Origin: https://app.example.com" \
+  -H "Authorization: Bearer <TOKEN>" \
+  "http://127.0.0.1:8790/v1/git/summary?repoPath=owner/repo"
+```
+
 ## Configuration
 
 Config is stored in OS-specific directories:

package/design.md

@@ -280,6 +280,10 @@ Meta response fields (examples):
 
   * returns: `{ branches: [{ name, fullName, type: "local"|"remote", current, upstream? }] }`
   * `includeRemote` defaults to `true` and includes remote tracking branches (e.g. `origin/main`)
+* `GET /v1/git/summary?repoPath=...` → status summary for UI badges/tooltips
+
+  * returns: `{ repoPath, exists, branch, upstream, ahead, behind, dirty, staged, unstaged, untracked, conflicts, detached }`
+  * if repo is missing, `exists` is `false` with zeroed counts
 * `GET /v1/git/status?repoPath=...` → structured status
 
   * returns: `{ branch, ahead, behind, stagedCount, unstagedCount, untrackedCount, conflictsCount, clean }`

package/openapi.yaml

@@ -208,6 +208,29 @@ paths:
           $ref: '#/components/responses/UnprocessableEntity'
         '500':
           $ref: '#/components/responses/InternalError'
+  /v1/git/summary:
+    get:
+      summary: Get repository status summary
+      parameters:
+        - $ref: '#/components/parameters/OriginHeader'
+        - $ref: '#/components/parameters/RepoPath'
+      responses:
+        '200':
+          description: Repository status summary
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/GitSummary'
+        '401':
+          $ref: '#/components/responses/Unauthorized'
+        '403':
+          $ref: '#/components/responses/Forbidden'
+        '409':
+          $ref: '#/components/responses/Conflict'
+        '422':
+          $ref: '#/components/responses/UnprocessableEntity'
+        '500':
+          $ref: '#/components/responses/InternalError'
   /v1/git/status:
     get:
       summary: Get repository status
@@ -581,6 +604,53 @@ components:
           minimum: 0
         clean:
           type: boolean
+    GitSummary:
+      type: object
+      required:
+        - repoPath
+        - exists
+        - branch
+        - upstream
+        - ahead
+        - behind
+        - dirty
+        - staged
+        - unstaged
+        - untracked
+        - conflicts
+        - detached
+      properties:
+        repoPath:
+          type: string
+        exists:
+          type: boolean
+        branch:
+          type: string
+        upstream:
+          type: string
+          nullable: true
+        ahead:
+          type: integer
+          minimum: 0
+        behind:
+          type: integer
+          minimum: 0
+        dirty:
+          type: boolean
+        staged:
+          type: integer
+          minimum: 0
+        unstaged:
+          type: integer
+          minimum: 0
+        untracked:
+          type: integer
+          minimum: 0
+        conflicts:
+          type: integer
+          minimum: 0
+        detached:
+          type: boolean
     GitBranchesResponse:
       type: object
       required:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-daemon",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "private": false,
   "type": "commonjs",
   "main": "dist/daemon.js",

package/src/app.ts

@@ -29,6 +29,7 @@ import {
   gitCloneRequestSchema,
   gitFetchRequestSchema,
   gitBranchesQuerySchema,
+  gitSummaryQuerySchema,
   gitStatusQuerySchema,
   osOpenRequestSchema,
   depsInstallRequestSchema,
@@ -43,6 +44,7 @@ import {
   cloneRepo,
   fetchRepo,
   listRepoBranches,
+  getRepoSummary,
   getRepoStatus,
   RepoNotFoundError,
   resolveRepoPath,
@@ -366,6 +368,43 @@ export const createApp = (ctx: DaemonContext) => {
     },
   );
 
+  app.get(
+    "/v1/git/summary",
+    authGuard(ctx.tokenStore),
+    async (req, res, next) => {
+      let payload: { repoPath: string } | undefined;
+      try {
+        payload = parseBody(gitSummaryQuerySchema, req.query);
+        const workspaceRoot = ensureWorkspaceRoot(ctx.config.workspaceRoot);
+        const summary = await getRepoSummary(workspaceRoot, payload.repoPath);
+        res.json(summary);
+      } catch (err) {
+        if (
+          (err instanceof RepoNotFoundError ||
+            err instanceof MissingPathError) &&
+          payload
+        ) {
+          res.json({
+            repoPath: payload.repoPath,
+            exists: false,
+            branch: "",
+            upstream: null,
+            ahead: 0,
+            behind: 0,
+            dirty: false,
+            staged: 0,
+            unstaged: 0,
+            untracked: 0,
+            conflicts: 0,
+            detached: false,
+          });
+          return;
+        }
+        next(err);
+      }
+    },
+  );
+
   app.get(
     "/v1/git/status",
     authGuard(ctx.tokenStore),

package/src/git.ts

@@ -23,6 +23,33 @@ export type GitBranch = {
   upstream?: string;
 };
 
+export type GitSummary = {
+  repoPath: string;
+  exists: boolean;
+  branch: string;
+  upstream: string | null;
+  ahead: number;
+  behind: number;
+  dirty: boolean;
+  staged: number;
+  unstaged: number;
+  untracked: number;
+  conflicts: number;
+  detached: boolean;
+};
+
+type GitStatusInfo = {
+  branch: string;
+  upstream: string | null;
+  ahead: number;
+  behind: number;
+  stagedCount: number;
+  unstagedCount: number;
+  untrackedCount: number;
+  conflictsCount: number;
+  detached: boolean;
+};
+
 export class RepoNotFoundError extends Error {}
 
 export const cloneRepo = async (
@@ -84,6 +111,42 @@ export const getRepoStatus = async (
   return parseStatus(result.stdout);
 };
 
+export const getRepoSummary = async (
+  workspaceRoot: string,
+  repoPath: string,
+): Promise<GitSummary> => {
+  const resolved = await resolveRepoPath(workspaceRoot, repoPath);
+  const { execa } = await import("execa");
+  const result = await execa("git", [
+    "-C",
+    resolved,
+    "status",
+    "--porcelain=2",
+    "-b",
+  ]);
+  const info = parseStatusInfo(result.stdout);
+  const dirty =
+    info.stagedCount > 0 ||
+    info.unstagedCount > 0 ||
+    info.untrackedCount > 0 ||
+    info.conflictsCount > 0;
+  const upstream = info.detached ? null : info.upstream;
+  return {
+    repoPath,
+    exists: true,
+    branch: info.branch,
+    upstream,
+    ahead: upstream ? info.ahead : 0,
+    behind: upstream ? info.behind : 0,
+    dirty,
+    staged: info.stagedCount,
+    unstaged: info.unstagedCount,
+    untracked: info.untrackedCount,
+    conflicts: info.conflictsCount,
+    detached: info.detached,
+  };
+};
+
 export const listRepoBranches = async (
   workspaceRoot: string,
   repoPath: string,
@@ -129,7 +192,29 @@ const assertRepoExists = async (repoPath: string) => {
 };
 
 const parseStatus = (output: string): GitStatus => {
-  let branch = "";
+  const info = parseStatusInfo(output);
+  const clean =
+    info.stagedCount === 0 &&
+    info.unstagedCount === 0 &&
+    info.untrackedCount === 0 &&
+    info.conflictsCount === 0;
+
+  return {
+    branch: info.branch,
+    ahead: info.ahead,
+    behind: info.behind,
+    stagedCount: info.stagedCount,
+    unstagedCount: info.unstagedCount,
+    untrackedCount: info.untrackedCount,
+    conflictsCount: info.conflictsCount,
+    clean,
+  };
+};
+
+const parseStatusInfo = (output: string): GitStatusInfo => {
+  let head = "";
+  let oid = "";
+  let upstream: string | null = null;
   let ahead = 0;
   let behind = 0;
   let stagedCount = 0;
@@ -140,7 +225,16 @@ const parseStatus = (output: string): GitStatus => {
   const lines = output.split(/\r?\n/);
   for (const line of lines) {
     if (line.startsWith("# branch.head")) {
-      branch = line.split(" ").slice(2).join(" ").trim();
+      head = line.split(" ").slice(2).join(" ").trim();
+      continue;
+    }
+    if (line.startsWith("# branch.oid")) {
+      oid = line.split(" ").slice(2).join(" ").trim();
+      continue;
+    }
+    if (line.startsWith("# branch.upstream")) {
+      const value = line.split(" ").slice(2).join(" ").trim();
+      upstream = value.length > 0 ? value : null;
       continue;
     }
     if (line.startsWith("# branch.ab")) {
@@ -171,21 +265,23 @@ const parseStatus = (output: string): GitStatus => {
     }
   }
 
-  const clean =
-    stagedCount === 0 &&
-    unstagedCount === 0 &&
-    untrackedCount === 0 &&
-    conflictsCount === 0;
+  const detached = head === "(detached)";
+  let branch = head;
+  if (detached) {
+    branch = oid || head;
+    upstream = null;
+  }
 
   return {
     branch,
+    upstream,
     ahead,
     behind,
     stagedCount,
     unstagedCount,
     untrackedCount,
     conflictsCount,
-    clean,
+    detached,
   };
 };
 

package/src/validation.ts

@@ -56,6 +56,10 @@ export const gitStatusQuerySchema = z.object({
   repoPath: z.string().min(1).max(MAX_PATH_LENGTH),
 });
 
+export const gitSummaryQuerySchema = z.object({
+  repoPath: z.string().min(1).max(MAX_PATH_LENGTH),
+});
+
 export const gitBranchesQuerySchema = z.object({
   repoPath: z.string().min(1).max(MAX_PATH_LENGTH),
   includeRemote: z.enum(["true", "false"]).optional(),

package/tests/app.test.ts

@@ -180,4 +180,54 @@ describe("Git Daemon API", () => {
     const originMain = branches.find((branch) => branch.name === "origin/main");
     expect(originMain?.type).toBe("remote");
   });
+
+  it("returns a UI-friendly status summary", async () => {
+    const workspaceRoot = await createTempDir();
+    const { repoPath } = await setupRepoWithRemote(workspaceRoot);
+    const repoDir = path.join(workspaceRoot, repoPath);
+    await fs.writeFile(path.join(repoDir, "scratch.txt"), "dirty");
+    const { app, ctx } = await createContext(workspaceRoot, origin);
+    const { token } = await ctx.tokenStore.issueToken(origin, 30);
+
+    const res = await request(app)
+      .get("/v1/git/summary")
+      .query({ repoPath })
+      .set("Origin", origin)
+      .set("Host", "127.0.0.1")
+      .set("Authorization", `Bearer ${token}`);
+
+    expect(res.status).toBe(200);
+    expect(res.body.repoPath).toBe(repoPath);
+    expect(res.body.exists).toBe(true);
+    expect(res.body.branch).toBe("feature");
+    expect(res.body.upstream).toBe("origin/feature");
+    expect(res.body.ahead).toBe(0);
+    expect(res.body.behind).toBe(0);
+    expect(res.body.dirty).toBe(true);
+    expect(res.body.untracked).toBe(1);
+    expect(res.body.staged).toBe(0);
+    expect(res.body.unstaged).toBe(0);
+    expect(res.body.conflicts).toBe(0);
+    expect(res.body.detached).toBe(false);
+  });
+
+  it("returns exists false when summary repo is missing", async () => {
+    const workspaceRoot = await createTempDir();
+    const { app, ctx } = await createContext(workspaceRoot, origin);
+    const { token } = await ctx.tokenStore.issueToken(origin, 30);
+
+    const res = await request(app)
+      .get("/v1/git/summary")
+      .query({ repoPath: "missing" })
+      .set("Origin", origin)
+      .set("Host", "127.0.0.1")
+      .set("Authorization", `Bearer ${token}`);
+
+    expect(res.status).toBe(200);
+    expect(res.body.exists).toBe(false);
+    expect(res.body.branch).toBe("");
+    expect(res.body.dirty).toBe(false);
+    expect(res.body.ahead).toBe(0);
+    expect(res.body.behind).toBe(0);
+  });
 });