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

package/lib/core/store.js

@@ -0,0 +1,120 @@
+/** Host-owned settings. Global and repository scopes are stored outside Git. */
+import { mkdir, readFile, writeFile, rename, rm } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+const HOME = () => process.env.DSH_HOME || join(homedir(), '.dsh');
+/** Stable fallback for existing v1 settings files without presentation preferences. */
+export const DEFAULT_COUNTDOWN_COLOR = '#f59e0b';
+const countdownColor = value => typeof value === 'string' && /^#[0-9a-fA-F]{6}$/.test(value)
+  ? value.toLowerCase() : DEFAULT_COUNTDOWN_COLOR;
+const validFloatingPosition = value => value !== null && value !== undefined && typeof value === 'object'
+  && !Array.isArray(value) && Number.isFinite(value.right) && Number.isFinite(value.top)
+  && value.right >= 0 && value.top >= 0 && value.right <= 100000 && value.top <= 100000;
+const defaults = () => ({ version: 1, global: { instruction: '', model: null, autoHideNonGit: false, showTokenDetails: false, countdownColor: DEFAULT_COUNTDOWN_COLOR, floatingPosition: null }, repositories: {} });
+const plain = (x) => x !== null && typeof x === 'object' && !Array.isArray(x);
+const string = (value, field, limit = 12000) => {
+  if (typeof value !== 'string' || value.length > limit) throw new Error(`${field} must be a string of at most ${limit} characters`);
+  return value;
+};
+/** null is the fixed 'inherit global' marker for repository model selection. */
+const storedModel = value => plain(value) && typeof value.provider === 'string' && value.provider.length > 0
+  && typeof value.model === 'string' && value.model.length > 0
+  ? { provider: value.provider, model: value.model } : null;
+const checkedModel = (value, key) => {
+  if (value === null) return null;
+  if (!plain(value) || typeof value.provider !== 'string' || typeof value.model !== 'string'
+    || !value.provider || !value.model) throw new Error(`Invalid ${key} selection`);
+  return { provider: string(value.provider, `${key}.provider`, 200),
+    model: string(value.model, `${key}.model`, 400) };
+};
+
+export class InstructionStore {
+  constructor(path = join(HOME(), 'dsh-git-commit.json')) {
+    this.path = path;
+    this.writes = Promise.resolve();
+  }
+  async read() {
+    try {
+      const data = JSON.parse(await readFile(this.path, 'utf8'));
+      if (!plain(data) || data.version !== 1) throw new Error('Unsupported commit settings version');
+      return { version: 1, global: plain(data.global) ? data.global : defaults().global, repositories: plain(data.repositories) ? data.repositories : {} };
+    } catch (error) {
+      if (error.code === 'ENOENT') return defaults();
+      throw error;
+    }
+  }
+  async get(root) {
+    const data = await this.read();
+    const repo = typeof root === 'string' && plain(data.repositories[root]) ? data.repositories[root] : {};
+    const model = storedModel(data.global?.model);
+    const repositoryModel = storedModel(repo.model);
+    return {
+      globalInstruction: typeof data.global?.instruction === 'string' ? data.global.instruction : '',
+      autoHideNonGit: data.global?.autoHideNonGit === true,
+      showTokenDetails: data.global?.showTokenDetails === true,
+      countdownColor: countdownColor(data.global?.countdownColor),
+      floatingPosition: validFloatingPosition(data.global?.floatingPosition)
+        ? {right:data.global.floatingPosition.right,top:data.global.floatingPosition.top} : null,
+      repositoryInstruction: typeof repo.instruction === 'string' ? repo.instruction : '',
+      inheritGlobal: repo.inheritGlobal !== false,
+      model,
+      repositoryModel,
+    };
+  }
+  async save(root, patch) {
+    const allowed = ['globalInstruction', 'repositoryInstruction', 'inheritGlobal', 'model', 'repositoryModel', 'autoHideNonGit', 'showTokenDetails', 'countdownColor', 'floatingPosition'];
+    if (!plain(patch) || Object.keys(patch).some(key => !allowed.includes(key))) throw new Error('Unknown commit setting');
+    if (root === null && ('repositoryInstruction' in patch || 'inheritGlobal' in patch || 'repositoryModel' in patch)) {
+      throw new Error('Repository-specific settings require a Git repository');
+    }
+    if (root !== null && (typeof root !== 'string' || !root)) throw new Error('Invalid repository scope');
+    const apply = async () => {
+      const data = await this.read();
+      const global = plain(data.global) ? data.global : {};
+      const current = root !== null && plain(data.repositories[root]) ? data.repositories[root] : {};
+      if ('globalInstruction' in patch) global.instruction = string(patch.globalInstruction, 'globalInstruction');
+      if ('autoHideNonGit' in patch) {
+        if (typeof patch.autoHideNonGit !== 'boolean') throw new Error('autoHideNonGit must be a boolean');
+        global.autoHideNonGit = patch.autoHideNonGit;
+      }
+      if ('showTokenDetails' in patch) {
+        if (typeof patch.showTokenDetails !== 'boolean') throw new Error('showTokenDetails must be a boolean');
+        global.showTokenDetails = patch.showTokenDetails;
+      }
+      if ('countdownColor' in patch) {
+        if (typeof patch.countdownColor !== 'string' || !/^#[0-9a-fA-F]{6}$/.test(patch.countdownColor)) {
+          throw new Error('countdownColor must be a #RRGGBB color');
+        }
+        global.countdownColor = patch.countdownColor.toLowerCase();
+      }
+      if ('floatingPosition' in patch) {
+        if (patch.floatingPosition !== null && !validFloatingPosition(patch.floatingPosition)) {
+          throw new Error('floatingPosition must be null or finite nonnegative right/top coordinates');
+        }
+        global.floatingPosition = patch.floatingPosition === null ? null
+          : {right:patch.floatingPosition.right,top:patch.floatingPosition.top};
+      }
+      if ('repositoryInstruction' in patch) current.instruction = string(patch.repositoryInstruction, 'repositoryInstruction');
+      if ('inheritGlobal' in patch) {
+        if (typeof patch.inheritGlobal !== 'boolean') throw new Error('inheritGlobal must be a boolean');
+        current.inheritGlobal = patch.inheritGlobal;
+      }
+      if ('model' in patch) global.model = checkedModel(patch.model, 'model');
+      if ('repositoryModel' in patch) current.model = checkedModel(patch.repositoryModel, 'repositoryModel');
+      data.global = global;
+      if (root !== null) data.repositories[root] = current;
+      await mkdir(dirname(this.path), { recursive: true });
+      const tmp = `${this.path}.${randomUUID()}.tmp`;
+      try {
+        await writeFile(tmp, JSON.stringify(data, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+        await rename(tmp, this.path);
+      } finally { await rm(tmp, { force: true }); }
+      return this.get(root);
+    };
+    const next = this.writes.then(apply);
+    this.writes = next.catch(() => {});
+    return next;
+  }
+}

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,81 @@
+/** 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;
+  /** Global model selection, null means use the DSH default. */
+  model: { provider: string; model: string } | null;
+  /** Repository-only override; null means inherit the global model selection (fixed UI option value). */
+  repositoryModel: { 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' | 'repositoryModel' | '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.1",
+  "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"
+  }
+}