zencommit 0.1.0

package/src/metadata/providers/local.ts

@@ -0,0 +1,66 @@
+import type { MetadataProvider, ModelMetadata } from '../types.js';
+import type { MetadataConfig } from '../../config/types.js';
+import { readJsonFile, resolvePath } from '../../util/fs.js';
+import { normalizeModelsDevData } from './modelsdev.js';
+import { logVerbose } from '../../util/logger.js';
+
+const normalizeLocalData = (data: unknown, fallbackIdPrefix = 'local'): ModelMetadata[] => {
+  if (Array.isArray(data)) {
+    return data
+      .map((entry) => entry as Partial<ModelMetadata>)
+      .filter((entry) => typeof entry.id === 'string')
+      .map((entry) => ({
+        id: entry.id ?? `${fallbackIdPrefix}/unknown`,
+        name: entry.name ?? entry.id ?? 'Unknown',
+        limits: entry.limits ?? { context: null, input: null, output: null },
+        pricing: entry.pricing,
+        capabilities: entry.capabilities,
+      }));
+  }
+  const normalized = normalizeModelsDevData(data);
+  if (normalized.length > 0) {
+    return normalized;
+  }
+  return [];
+};
+
+export const createLocalProvider = (
+  config: MetadataConfig,
+  repoRoot: string | null,
+): MetadataProvider => {
+  let cachedModels: ModelMetadata[] | null = null;
+
+  const loadModels = async (): Promise<ModelMetadata[]> => {
+    if (cachedModels) {
+      logVerbose(2, 'metadata: using in-memory local cache');
+      return cachedModels;
+    }
+    const resolvedPath = resolvePath(config.providers.local.path, repoRoot ?? process.cwd());
+    logVerbose(1, `metadata: loading local file ${resolvedPath}`);
+    const data = await readJsonFile<unknown>(resolvedPath);
+    if (!data) {
+      throw new Error(`Local metadata file not found at ${resolvedPath}`);
+    }
+    cachedModels = normalizeLocalData(data, 'local');
+    return cachedModels;
+  };
+
+  return {
+    async getModel(modelId: string) {
+      const models = await loadModels();
+      return models.find((model) => model.id === modelId) ?? null;
+    },
+    async search(query: string, limit = 20) {
+      const models = await loadModels();
+      const normalized = query.toLowerCase();
+      const results = models.filter((model) =>
+        `${model.id} ${model.name}`.toLowerCase().includes(normalized),
+      );
+      return results.slice(0, limit);
+    },
+    async list() {
+      const models = await loadModels();
+      return models;
+    },
+  };
+};

package/src/metadata/providers/modelsdev.ts

@@ -0,0 +1,145 @@
+import path from 'node:path';
+import type { ModelMetadata, MetadataProvider } from '../types.js';
+import { getCacheRoot } from '../../util/fs.js';
+import { isCacheFresh, readCache, writeCache } from '../cache.js';
+import type { MetadataConfig } from '../../config/types.js';
+import { getVerbosity, logVerbose } from '../../util/logger.js';
+
+const toNumberOrNull = (value: unknown): number | null => {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return value;
+  }
+  return null;
+};
+
+const normalizeModelId = (providerId: string, modelId: string): string => {
+  if (modelId.includes('/')) {
+    return modelId;
+  }
+  return `${providerId}/${modelId}`;
+};
+
+const toStringSafe = (value: unknown, fallback: string): string =>
+  typeof value === 'string' && value.trim().length > 0 ? value : fallback;
+
+export const normalizeModelsDevData = (data: unknown): ModelMetadata[] => {
+  if (!data || typeof data !== 'object') {
+    return [];
+  }
+
+  const entries = Object.entries(data as Record<string, unknown>);
+  const models: ModelMetadata[] = [];
+
+  for (const [providerKey, providerValue] of entries) {
+    if (!providerValue || typeof providerValue !== 'object') {
+      continue;
+    }
+    const provider = providerValue as Record<string, unknown>;
+    const providerId = toStringSafe(provider.id, providerKey);
+    const providerModels = provider.models;
+    if (!providerModels || typeof providerModels !== 'object') {
+      continue;
+    }
+
+    for (const [modelKey, modelValue] of Object.entries(
+      providerModels as Record<string, unknown>,
+    )) {
+      if (!modelValue || typeof modelValue !== 'object') {
+        continue;
+      }
+      const model = modelValue as Record<string, unknown>;
+      const rawId = toStringSafe(model.id, modelKey);
+      const id = normalizeModelId(providerId, rawId);
+      const name = toStringSafe(model.name, rawId);
+      const limit = (model.limit ?? model.limits ?? {}) as Record<string, unknown>;
+      const limits = {
+        context: toNumberOrNull(limit.context),
+        input: toNumberOrNull(limit.input),
+        output: toNumberOrNull(limit.output),
+      };
+      const pricing = model.cost ?? model.pricing;
+      const capabilities = {
+        attachment: model.attachment,
+        reasoning: model.reasoning,
+        toolCall: model.tool_call,
+        structuredOutput: model.structured_output,
+        modalities: model.modalities,
+        family: model.family,
+        openWeights: model.open_weights,
+      };
+
+      models.push({ id, name, limits, pricing, capabilities });
+    }
+  }
+
+  return models;
+};
+
+export const createModelsDevProvider = (config: MetadataConfig): MetadataProvider => {
+  const cachePath = path.join(getCacheRoot(), 'zencommit', 'metadata', 'modelsdev.cache.json');
+  let cachedModels: ModelMetadata[] | null = null;
+
+  const loadModels = async (): Promise<ModelMetadata[]> => {
+    if (cachedModels) {
+      logVerbose(2, 'metadata: using in-memory models.dev cache');
+      return cachedModels;
+    }
+
+    const cache = await readCache(cachePath);
+    const cacheFresh =
+      cache && isCacheFresh(cache.mtimeMs, config.providers.modelsdev.cacheTtlHours);
+
+    if (cacheFresh && cache) {
+      logVerbose(2, `metadata: cache hit ${cachePath}`);
+      cachedModels = normalizeModelsDevData(cache.data);
+      return cachedModels;
+    }
+
+    try {
+      if (getVerbosity() >= 1) {
+        logVerbose(1, `metadata: fetching ${config.providers.modelsdev.url}`);
+      }
+      const response = await fetch(config.providers.modelsdev.url);
+      if (!response.ok) {
+        throw new Error(`models.dev responded with ${response.status}`);
+      }
+      const data = (await response.json()) as unknown;
+      await writeCache(cachePath, data);
+      logVerbose(2, `metadata: cache write ${cachePath}`);
+      cachedModels = normalizeModelsDevData(data);
+      return cachedModels;
+    } catch (error) {
+      if (cache) {
+        const staleNote = cacheFresh ? '' : ' (cache is stale)';
+        console.warn(`models.dev fetch failed, using cached metadata${staleNote}.`);
+        logVerbose(2, `metadata: cache fallback ${cachePath}${staleNote}`);
+        cachedModels = normalizeModelsDevData(cache.data);
+        return cachedModels;
+      }
+      throw error;
+    }
+  };
+
+  return {
+    async getModel(modelId: string) {
+      const models = await loadModels();
+      return models.find((model) => model.id === modelId) ?? null;
+    },
+    async search(query: string, limit = 20) {
+      const models = await loadModels();
+      const normalized = query.toLowerCase();
+      const results = models.filter((model) =>
+        `${model.id} ${model.name}`.toLowerCase().includes(normalized),
+      );
+      return results.slice(0, limit);
+    },
+    async list() {
+      const models = await loadModels();
+      return models;
+    },
+    async refresh() {
+      cachedModels = null;
+      await loadModels();
+    },
+  };
+};

package/src/metadata/types.ts

@@ -0,0 +1,20 @@
+export interface ModelLimits {
+  context: number | null;
+  input: number | null;
+  output: number | null;
+}
+
+export interface ModelMetadata {
+  id: string;
+  name: string;
+  limits: ModelLimits;
+  pricing?: unknown;
+  capabilities?: unknown;
+}
+
+export interface MetadataProvider {
+  getModel(modelId: string): Promise<ModelMetadata | null>;
+  search(query: string, limit?: number): Promise<ModelMetadata[]>;
+  list?(): Promise<ModelMetadata[]>;
+  refresh?(): Promise<void>;
+}

package/src/ui/editor.ts

@@ -0,0 +1,33 @@
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export const openEditor = async (initialText: string): Promise<string> => {
+  const editor = process.env.EDITOR;
+  if (!editor) {
+    return initialText;
+  }
+
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'zencommit-'));
+  const filePath = path.join(tempDir, 'COMMIT_EDITMSG');
+  await fs.writeFile(filePath, `${initialText.trim()}\n`, 'utf8');
+
+  const [command, ...args] = editor.split(' ');
+  if (!command) {
+    return initialText;
+  }
+
+  const proc = Bun.spawn([command, ...args, filePath], {
+    stdin: 'inherit',
+    stdout: 'inherit',
+    stderr: 'inherit',
+  });
+
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    return initialText;
+  }
+
+  const updated = await fs.readFile(filePath, 'utf8');
+  return updated.trim();
+};

package/src/ui/prompts.ts

@@ -0,0 +1,99 @@
+import { autocomplete, cancel, isCancel, password, select } from '@clack/prompts';
+import { getProviderAuthConfigs } from '../auth/secrets.js';
+
+export type ConfirmAction = 'commit' | 'edit' | 'cancel';
+
+export const confirmCommit = async (message: string): Promise<ConfirmAction> => {
+  const action = await select({
+    message: message.trim().length > 0 ? message : 'Commit message',
+    options: [
+      { value: 'commit', label: 'Commit' },
+      { value: 'edit', label: 'Edit' },
+      { value: 'cancel', label: 'Cancel' },
+    ],
+  });
+
+  if (isCancel(action)) {
+    cancel('Canceled');
+    return 'cancel';
+  }
+
+  if (action === 'commit' || action === 'edit' || action === 'cancel') {
+    return action;
+  }
+  return 'cancel';
+};
+
+export const selectProviderKey = async (): Promise<string | null> => {
+  const configs = getProviderAuthConfigs();
+  const options = new Map<string, string>();
+  for (const config of configs) {
+    for (const envKey of config.envKeys) {
+      if (!options.has(envKey)) {
+        options.set(envKey, `${config.name} (${envKey})`);
+      }
+    }
+  }
+
+  const action = await autocomplete({
+    message: 'Select provider key',
+    options: Array.from(options.entries()).map(([value, label]) => ({ value, label })),
+    placeholder: 'Type to search providers...',
+    maxItems: 12,
+  });
+
+  if (isCancel(action)) {
+    cancel('Canceled');
+    return null;
+  }
+
+  if (typeof action === 'string') {
+    return action;
+  }
+  return null;
+};
+
+export const promptForSecret = async (envKey: string): Promise<string | null> => {
+  const value = await password({
+    message: `Enter ${envKey}`,
+    mask: '*',
+  });
+
+  if (isCancel(value)) {
+    cancel('Canceled');
+    return null;
+  }
+
+  if (typeof value === 'string') {
+    return value;
+  }
+  return null;
+};
+
+export const promptForModelSelection = async (
+  options: Array<{ id: string; name: string }>,
+  initialInput?: string,
+  maxItems = 10,
+): Promise<string | null> => {
+  const value = await autocomplete({
+    message: 'Search models',
+    options: options.map((model) => ({
+      value: model.id,
+      label: model.id,
+      hint: model.name,
+    })),
+    placeholder: 'Type to search models...',
+    maxItems,
+    initialUserInput: initialInput,
+  });
+
+  if (isCancel(value)) {
+    cancel('Canceled');
+    return null;
+  }
+
+  if (typeof value === 'string') {
+    return value;
+  }
+  return null;
+};

package/src/util/exec.ts

@@ -0,0 +1,57 @@
+import { getVerbosity, logBlock, logVerbose } from './logger.js';
+
+export class ExecError extends Error {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+
+  constructor(message: string, exitCode: number, stdout: string, stderr: string) {
+    super(message);
+    this.name = 'ExecError';
+    this.exitCode = exitCode;
+    this.stdout = stdout;
+    this.stderr = stderr;
+  }
+}
+
+export interface ExecOptions {
+  cwd?: string;
+  allowFailure?: boolean;
+  env?: Record<string, string | undefined>;
+}
+
+export interface ExecResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+export const exec = async (command: string[], options: ExecOptions = {}): Promise<ExecResult> => {
+  if (getVerbosity() >= 2) {
+    logVerbose(2, `exec: ${command.join(' ')}`);
+  }
+  const proc = Bun.spawn(command, {
+    cwd: options.cwd,
+    env: options.env ? { ...process.env, ...options.env } : process.env,
+    stdout: 'pipe',
+    stderr: 'pipe',
+  });
+
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+
+  if (getVerbosity() >= 3) {
+    logVerbose(3, `exec exit: ${exitCode}`);
+    logBlock(3, 'exec stdout', stdout);
+    logBlock(3, 'exec stderr', stderr);
+  }
+
+  if (exitCode !== 0 && !options.allowFailure) {
+    throw new ExecError(`Command failed: ${command.join(' ')}`, exitCode, stdout, stderr);
+  }
+
+  return { stdout, stderr, exitCode };
+};

package/src/util/fs.ts

@@ -0,0 +1,46 @@
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export const getConfigRoot = (): string =>
+  process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), '.config');
+
+export const getCacheRoot = (): string =>
+  process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache');
+
+export const ensureDir = async (dirPath: string): Promise<void> => {
+  await fs.mkdir(dirPath, { recursive: true });
+};
+
+export const fileExists = async (filePath: string): Promise<boolean> => {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export const readJsonFile = async <T>(filePath: string): Promise<T | null> => {
+  if (!(await fileExists(filePath))) {
+    return null;
+  }
+  const content = await fs.readFile(filePath, 'utf8');
+  return JSON.parse(content) as T;
+};
+
+export const writeJsonFile = async (filePath: string, data: unknown): Promise<void> => {
+  await ensureDir(path.dirname(filePath));
+  const content = `${JSON.stringify(data, null, 2)}\n`;
+  await fs.writeFile(filePath, content, 'utf8');
+};
+
+export const resolvePath = (inputPath: string, baseDir?: string): string => {
+  if (path.isAbsolute(inputPath)) {
+    return inputPath;
+  }
+  if (baseDir) {
+    return path.join(baseDir, inputPath);
+  }
+  return path.resolve(inputPath);
+};

package/src/util/logger.ts

@@ -0,0 +1,50 @@
+let verbosity = 0;
+
+const clampVerbosity = (level: number): number => {
+  if (!Number.isFinite(level)) {
+    return 0;
+  }
+  return Math.max(0, Math.min(3, Math.floor(level)));
+};
+
+export const setVerbosity = (level: number): void => {
+  verbosity = clampVerbosity(level);
+};
+
+export const getVerbosity = (): number => verbosity;
+
+const prefix = (level: number): string => `[v${level}]`;
+
+export const logVerbose = (level: number, message: string, data?: unknown): void => {
+  if (verbosity < level) {
+    return;
+  }
+  if (data !== undefined) {
+    console.error(`${prefix(level)} ${message}`, data);
+    return;
+  }
+  console.error(`${prefix(level)} ${message}`);
+};
+
+export const logBlock = (level: number, label: string, content?: unknown): void => {
+  if (verbosity < level) {
+    return;
+  }
+  console.error(`${prefix(level)} ${label}`);
+  if (content === undefined) {
+    return;
+  }
+  if (typeof content === 'string') {
+    const trimmed = content.trimEnd();
+    console.error(trimmed.length > 0 ? trimmed : '(empty)');
+    return;
+  }
+  console.error(JSON.stringify(content, null, 2));
+};
+
+export const logJson = (level: number, label: string, value: unknown): void => {
+  if (verbosity < level) {
+    return;
+  }
+  logBlock(level, label, JSON.stringify(value, null, 2));
+};

package/src/util/redact.ts

@@ -0,0 +1,30 @@
+const SENSITIVE_KEY_RE = /(key|token|secret|password)/i;
+
+export const redactValue = (value: string, keep = 4): string => {
+  if (!value) {
+    return '';
+  }
+  if (value.length <= keep) {
+    return '*'.repeat(value.length);
+  }
+  const visible = value.slice(-keep);
+  return `${'*'.repeat(Math.max(0, value.length - keep))}${visible}`;
+};
+
+export const redactObject = (value: unknown): unknown => {
+  if (Array.isArray(value)) {
+    return value.map((entry) => redactObject(entry));
+  }
+  if (value && typeof value === 'object') {
+    const result: Record<string, unknown> = {};
+    for (const [key, entry] of Object.entries(value)) {
+      if (typeof entry === 'string' && SENSITIVE_KEY_RE.test(key)) {
+        result[key] = redactValue(entry);
+      } else {
+        result[key] = redactObject(entry);
+      }
+    }
+    return result;
+  }
+  return value;
+};