@ibobbyts/dsh-git-commit 0.0.0-stage → 0.2.0

package/lib/core/watcher.js

@@ -0,0 +1,57 @@
+/** Change tokens keep browser polling cheap: Git is queried only on changes. */
+import { watch } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { git } from './git.js';
+
+const IGNORE = new Set(['.git', 'node_modules', 'dist', 'build', 'coverage', 'target', '.next', '.venv', '__pycache__']);
+export class RepoWatcher {
+  constructor() { this.repos = new Map(); this.seed = 0; }
+  async token(root) {
+    let record = this.repos.get(root);
+    if (record) return record.token;
+    record = { token: ++this.seed, handles: [], timer: null, first: 0 };
+    this.repos.set(root, record);
+    const publish = () => { record.token += 1; record.first = 0; record.timer = null; };
+    const bump = () => {
+      const now = Date.now();
+      if (!record.first) record.first = now;
+      if (record.timer) clearTimeout(record.timer);
+      if (now - record.first > 1000) return publish();
+      record.timer = setTimeout(publish, 160);
+      record.timer.unref?.();
+    };
+    const listen = (path, options, filter) => {
+      try {
+        const handle = watch(path, options, (_, file) => { if (filter(file)) bump(); });
+        handle.on('error', () => bump());
+        handle.unref?.();
+        record.handles.push(handle);
+      } catch { /* A low-frequency client fallback still ensures eventual refresh. */ }
+    };
+    listen(root, { recursive: true }, path => {
+      if (!path) return true;
+      const first = String(path).replaceAll('\\', '/').split('/')[0];
+      return !IGNORE.has(first);
+    });
+    // Git worktrees have a .git FILE, and common refs may live in another checkout.
+    for (const path of ['HEAD', 'index', 'packed-refs', 'refs', 'MERGE_HEAD']) {
+      try {
+        const actual = (await git(root, ['rev-parse', '--git-path', path])).trim();
+        const full = resolve(root, actual);
+        listen(dirname(full), {}, name => {
+          if (!name) return true;
+          if (path === 'refs') return String(name) === 'refs';
+          return String(name) === path.split('/').at(-1);
+        });
+      } catch { /* Path may not exist on a freshly initialized repository. */ }
+    }
+    return record.token;
+  }
+  close() {
+    for (const record of this.repos.values()) {
+      if (record.timer) clearTimeout(record.timer);
+      for (const handle of record.handles) handle.close();
+    }
+    this.repos.clear();
+  }
+}

package/lib/index.d.ts

@@ -0,0 +1,78 @@
+/** Public host-facing API for DSH plugins. */
+export interface GitCommitRequest {
+  /** Working directory inside the repository. Prefer an explicit cwd from another plugin. */
+  cwd?: string;
+  repositoryPath?: string;
+  sessionId?: string;
+  /** Optional caller-supplied message; skips AI generation but preserves scope/snapshot validation. */
+  message?: string;
+  signal?: AbortSignal;
+}
+/** Provider usage totals and local monotonic timings across at most two LLM calls. */
+export interface GitCommitLlmMetrics {
+  calls: number;
+  /** Total input including uncached, cache-read, and cache-write tokens. Null if usage unavailable. */
+  inputTokens: number | null;
+  outputTokens: number | null;
+  cacheReadTokens: number | null;
+  cacheWriteTokens: number | null;
+  reasoningTokens: number | null;
+  /** Earliest content token across calls, relative to first request's start. */
+  latencyMs: number | null;
+  /** LLM phase elapsed wall-clock time. */
+  durationMs: number;
+  /** Total output tokens / sum of per-call decoding times. Null if data incomplete. */
+  outputSpeedTps: number | null;
+}
+export interface GitCommitResult {
+  success: boolean;
+  status: 'success' | 'failure';
+  scope: 'staged' | 'all' | null;
+  additions: number;
+  deletions: number;
+  message: string;
+  /** Exactly the first seven characters of the resulting commit OID, or null upon failure. */
+  hash: string | null;
+  fullHash?: string;
+  /** Present when an LLM was invoked; caller-supplied messages omit this. */
+  llm?: GitCommitLlmMetrics;
+  totalDurationMs?: number;
+  error?: string;
+}
+export interface GitCommitSettings {
+  globalInstruction: string;
+  repositoryInstruction: string;
+  inheritGlobal: boolean;
+  /** Global preference, defaults to false; affects floating panel only. */
+  autoHideNonGit: boolean;
+  /** Global setting; defaults to false. */
+  showTokenDetails: boolean;
+  /** Progress bar color in #rrggbb form; defaults to orange (#f59e0b). */
+  countdownColor: string;
+  /** Null means default lower-right anchor. Otherwise saved top/right coordinates in CSS pixels. */
+  floatingPosition: {right:number;top:number} | null;
+  model: { provider: string; model: string } | null;
+  /** True for a Git working tree; false for global-only settings in ordinary directories. */
+  isRepository: boolean;
+  /** Canonical Git root, or null outside a repository. */
+  root: string | null;
+}
+export interface GitCommitApi {
+  commit(request: GitCommitRequest): Promise<GitCommitResult>;
+  status(request: GitCommitRequest): Promise<
+    | { isRepository: false; root: null }
+    | { isRepository: true; root: string; repo: string; branch: string; head: string;
+        additions: number; deletions: number; binary: number;
+        untracked: number; unknownUntrackedLines: number; stagedFiles: number }
+  >;
+  changeToken(request: GitCommitRequest): Promise<{ token: number | null }>;
+  settings(request?: GitCommitRequest): Promise<GitCommitSettings>;
+  saveSettings(request: GitCommitRequest & { patch: Partial<Pick<GitCommitSettings, 'globalInstruction' | 'repositoryInstruction' | 'inheritGlobal' | 'model' | 'autoHideNonGit' | 'showTokenDetails' | 'countdownColor' | 'floatingPosition'>> }): Promise<GitCommitSettings>;
+  models(): Promise<{ models: Array<{provider:string;providerName:string;model:string;name:string}>; defaultModel: {provider:string;model:string}|null }>;
+}
+declare module '@deepseek-ai/cordis' {
+  interface Context { gitCommit: GitCommitApi; }
+}
+export const name: string;
+export const inject: string[];
+export function apply(ctx: import('@deepseek-ai/cordis').Context): void;

package/lib/index.js

@@ -0,0 +1,80 @@
+/**
+ * DSH Host plugin. Register a feature endpoint on Connection's already-authenticated
+ * /api transport, NOT a new webServer route. Connection's own host context does
+ * not inject webServer and ctx.connection.rpc.handle() can trigger Cordis's
+ * "cannot get property webServer without inject" on that shadow context.
+ *
+ * Browser/desktop clients use the public connection.rpc.call('/api', 'git-commit', ...)
+ * protocol. Other host plugins use the in-process ctx.gitCommit service.
+ */
+import { GitCommitService } from './core/service.js';
+
+export const name = 'dsh-git-commit';
+export const inject = ['connection', 'llm'];
+export const ROUTE = '/api/git-commit';
+const ENDPOINT = 'git-commit';
+const COMMANDS = new Set(['status', 'changeToken', 'settings', 'saveSettings', 'models', 'commit']);
+const MAX_REQUEST_CHARS = 262_144;
+const HEADERS = { 'cache-control': 'no-store', 'x-content-type-options': 'nosniff' };
+
+function record(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function response(rpcId, result) {
+  return Response.json({ type: 'server-response', rpcId, result }, { headers: HEADERS });
+}
+
+function failure(code, error) {
+  return { ok: false, error: { code, message: error instanceof Error ? error.message : String(error), details: {} } };
+}
+
+/**
+ * The DSH Connection bridge has already authenticated the caller and enforces
+ * an owner principal for exact Fetch routes. We only validate application input
+ * and return the standard Connection RPC response envelope here.
+ */
+export function createHandler(service) {
+  return async function serve(request) {
+    const contentType = request.headers.get('content-type')?.split(';', 1)[0]?.trim().toLowerCase();
+    if (request.method !== 'POST') return new Response('Method not allowed', { status: 405, headers: HEADERS });
+    if (contentType !== 'application/json') return new Response('JSON required', { status: 415, headers: HEADERS });
+    let input;
+    try {
+      const text = await request.text();
+      if (text.length > MAX_REQUEST_CHARS) return new Response('Request too large', { status: 413, headers: HEADERS });
+      input = JSON.parse(text);
+    } catch {
+      return new Response('Invalid JSON', { status: 400, headers: HEADERS });
+    }
+    if (!record(input) || input.type !== 'client-request' || input.method !== ENDPOINT
+      || typeof input.rpcId !== 'string' || input.rpcId.length === 0 || input.rpcId.length > 256
+      || !record(input.payload) || typeof input.payload.method !== 'string') {
+      return new Response('Invalid Connection request', { status: 400, headers: HEADERS });
+    }
+    const { method, payload } = input.payload;
+    if (!COMMANDS.has(method)) return response(input.rpcId, failure('NOT_FOUND', 'Unknown method'));
+    const args = record(payload) ? payload : {};
+    try {
+      const value = await service[method](method === 'commit' ? { ...args, signal: request.signal } : args);
+      return response(input.rpcId, { ok: true, value });
+    } catch (error) {
+      return response(input.rpcId, failure('GIT_COMMIT_ERROR', error));
+    }
+  };
+}
+
+export function apply(ctx) {
+  const service = new GitCommitService(ctx);
+  // Cordis-native, injected by other Host plugins via inject: ['gitCommit'].
+  const release = ctx.reflect.provide('gitCommit', service);
+  ctx.effect(() => () => { service.close(); return release(); }, 'dsh-git-commit: service cleanup');
+  // Connection handles authentication, Origin trust, and DSH Web/Desktop transport.
+  // Use the same exact Fetch-route seam as DSH's /api/file and /api/present.
+  ctx.effect(() => ctx.connection.fetch.register({
+    path: ROUTE,
+    methods: ['POST'],
+    requestBody: 'buffered',
+    fetch: createHandler(service),
+  }), 'dsh-git-commit: authenticated API route');
+}

package/package.json

@@ -1,6 +1,75 @@
 {
   "name": "@ibobbyts/dsh-git-commit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "type": "module",
+  "description": "Floating Git stats and AI commits with native DSH LLM, authenticated RPC, settings and shared service",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-ui-session",
+        "@deepseek-ai/dsh-client-ui-sidebar-right"
+      ],
+      "immediately": true
+    }
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE",
+    "THIRD_PARTY.md"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.js",
+    "check": "node --check lib/index.js && node --check lib/client.js && node --test test/*.test.js",
+    "prepublishOnly": "npm run check"
+  },
+  "dependencies": {
+    "@visulima/redact": "5.0.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-llm": ">=0.1.1-rc.2"
+  },
+  "engines": {
+    "node": ">=22.22.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iBobbyTS/dsh-git-commit.git"
+  },
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "git",
+    "commit",
+    "ai",
+    "plugin"
+  ],
+  "types": "lib/index.d.ts",
+  "homepage": "https://github.com/iBobbyTS/dsh-git-commit#readme",
+  "bugs": {
+    "url": "https://github.com/iBobbyTS/dsh-git-commit/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  }
+}