zencommit 0.1.0

package/src/config/types.ts

@@ -0,0 +1,119 @@
+export type CommitStyle = 'conventional' | 'freeform';
+export type DiffMode = 'staged' | 'unstaged' | 'all';
+export type TruncateStrategy = 'byFile' | 'smart';
+export type MetadataProviderName = 'auto' | 'modelsdev' | 'local';
+
+export interface AiConfig {
+  model: string;
+  temperature: number;
+  maxOutputTokens: number;
+  timeoutMs: number;
+  openaiCompatible?: OpenAICompatibleConfig;
+}
+
+export interface OpenAICompatibleConfig {
+  baseUrl?: string;
+  name?: string;
+}
+
+export interface CommitConfig {
+  style: CommitStyle;
+  language: string;
+  includeBody: boolean;
+  emoji: boolean;
+}
+
+export interface GitConfig {
+  diffMode: DiffMode;
+  autoStage: boolean;
+  confirmBeforeCommit: boolean;
+}
+
+export interface DiffSmartConfig {
+  maxAddedLinesPerHunk: number;
+  maxRemovedLinesPerHunk: number;
+}
+
+export interface DiffConfig {
+  truncateStrategy: TruncateStrategy;
+  includeFileList: boolean;
+  excludeGitignoreFiles: boolean;
+  maxFiles: number;
+  smart: DiffSmartConfig;
+}
+
+export interface ModelsDevProviderConfig {
+  url: string;
+  cacheTtlHours: number;
+}
+
+export interface LocalProviderConfig {
+  path: string;
+}
+
+export interface MetadataProvidersConfig {
+  modelsdev: ModelsDevProviderConfig;
+  local: LocalProviderConfig;
+}
+
+export interface MetadataConfig {
+  provider: MetadataProviderName;
+  fallbackOrder: Array<Exclude<MetadataProviderName, 'auto'>>;
+  providers: MetadataProvidersConfig;
+}
+
+export interface AuthConfig {
+  preferredEnvKey?: string;
+}
+
+export interface ResolvedConfig {
+  ai: AiConfig;
+  commit: CommitConfig;
+  git: GitConfig;
+  diff: DiffConfig;
+  metadata: MetadataConfig;
+  auth?: AuthConfig;
+}
+
+export const defaultConfig: ResolvedConfig = {
+  ai: {
+    model: 'openai/gpt-5',
+    temperature: 0.2,
+    maxOutputTokens: 4096,
+    timeoutMs: 20000,
+  },
+  commit: {
+    style: 'conventional',
+    language: 'en',
+    includeBody: true,
+    emoji: false,
+  },
+  git: {
+    diffMode: 'staged',
+    autoStage: false,
+    confirmBeforeCommit: true,
+  },
+  diff: {
+    truncateStrategy: 'smart',
+    includeFileList: true,
+    excludeGitignoreFiles: true,
+    maxFiles: 200,
+    smart: {
+      maxAddedLinesPerHunk: 12,
+      maxRemovedLinesPerHunk: 12,
+    },
+  },
+  metadata: {
+    provider: 'auto',
+    fallbackOrder: ['modelsdev', 'local'],
+    providers: {
+      modelsdev: {
+        url: 'https://models.dev/api.json',
+        cacheTtlHours: 24,
+      },
+      local: {
+        path: './models.metadata.json',
+      },
+    },
+  },
+};

package/src/config/validate.ts

@@ -0,0 +1,139 @@
+import type { DiffMode, MetadataProviderName, ResolvedConfig, TruncateStrategy } from './types.js';
+
+export interface ValidationError {
+  path: string;
+  message: string;
+}
+
+export interface ValidationResult {
+  valid: boolean;
+  errors: ValidationError[];
+}
+
+const addError = (errors: ValidationError[], path: string, message: string): void => {
+  errors.push({ path, message });
+};
+
+const isString = (value: unknown): value is string => typeof value === 'string';
+const isBoolean = (value: unknown): value is boolean => typeof value === 'boolean';
+const isNumber = (value: unknown): value is number =>
+  typeof value === 'number' && !Number.isNaN(value);
+
+const isDiffMode = (value: unknown): value is DiffMode =>
+  value === 'staged' || value === 'unstaged' || value === 'all';
+
+const isTruncateStrategy = (value: unknown): value is TruncateStrategy =>
+  value === 'byFile' || value === 'smart';
+
+const isProviderName = (value: unknown): value is MetadataProviderName =>
+  value === 'auto' || value === 'modelsdev' || value === 'local';
+
+export const validateConfig = (config: ResolvedConfig): ValidationResult => {
+  const errors: ValidationError[] = [];
+
+  if (!isString(config.ai.model) || config.ai.model.trim().length === 0) {
+    addError(errors, 'ai.model', 'Model must be a non-empty string.');
+  }
+  if (!isNumber(config.ai.temperature)) {
+    addError(errors, 'ai.temperature', 'Temperature must be a number.');
+  }
+  if (!isNumber(config.ai.maxOutputTokens) || config.ai.maxOutputTokens <= 0) {
+    addError(errors, 'ai.maxOutputTokens', 'Max output tokens must be a positive number.');
+  }
+  if (!isNumber(config.ai.timeoutMs) || config.ai.timeoutMs <= 0) {
+    addError(errors, 'ai.timeoutMs', 'Timeout must be a positive number.');
+  }
+  if (config.ai.openaiCompatible) {
+    if (
+      config.ai.openaiCompatible.baseUrl !== undefined &&
+      (!isString(config.ai.openaiCompatible.baseUrl) ||
+        config.ai.openaiCompatible.baseUrl.trim().length === 0)
+    ) {
+      addError(
+        errors,
+        'ai.openaiCompatible.baseUrl',
+        'openaiCompatible.baseUrl must be a non-empty string.',
+      );
+    }
+    if (
+      config.ai.openaiCompatible.name !== undefined &&
+      !isString(config.ai.openaiCompatible.name)
+    ) {
+      addError(errors, 'ai.openaiCompatible.name', 'openaiCompatible.name must be a string.');
+    }
+  }
+
+  if (config.commit.style !== 'conventional' && config.commit.style !== 'freeform') {
+    addError(errors, 'commit.style', 'Style must be conventional or freeform.');
+  }
+  if (!isString(config.commit.language)) {
+    addError(errors, 'commit.language', 'Language must be a string.');
+  }
+  if (!isBoolean(config.commit.includeBody)) {
+    addError(errors, 'commit.includeBody', 'includeBody must be a boolean.');
+  }
+  if (!isBoolean(config.commit.emoji)) {
+    addError(errors, 'commit.emoji', 'emoji must be a boolean.');
+  }
+
+  if (!isDiffMode(config.git.diffMode)) {
+    addError(errors, 'git.diffMode', 'diffMode must be staged, unstaged, or all.');
+  }
+  if (!isBoolean(config.git.autoStage)) {
+    addError(errors, 'git.autoStage', 'autoStage must be a boolean.');
+  }
+  if (!isBoolean(config.git.confirmBeforeCommit)) {
+    addError(errors, 'git.confirmBeforeCommit', 'confirmBeforeCommit must be a boolean.');
+  }
+
+  if (!isTruncateStrategy(config.diff.truncateStrategy)) {
+    addError(errors, 'diff.truncateStrategy', 'truncateStrategy must be byFile or smart.');
+  }
+  if (!isBoolean(config.diff.includeFileList)) {
+    addError(errors, 'diff.includeFileList', 'includeFileList must be a boolean.');
+  }
+  if (!isBoolean(config.diff.excludeGitignoreFiles)) {
+    addError(errors, 'diff.excludeGitignoreFiles', 'excludeGitignoreFiles must be a boolean.');
+  }
+  if (!isNumber(config.diff.maxFiles) || config.diff.maxFiles <= 0) {
+    addError(errors, 'diff.maxFiles', 'maxFiles must be a positive number.');
+  }
+  if (
+    !isNumber(config.diff.smart.maxAddedLinesPerHunk) ||
+    config.diff.smart.maxAddedLinesPerHunk <= 0
+  ) {
+    addError(errors, 'diff.smart.maxAddedLinesPerHunk', 'maxAddedLinesPerHunk must be positive.');
+  }
+  if (
+    !isNumber(config.diff.smart.maxRemovedLinesPerHunk) ||
+    config.diff.smart.maxRemovedLinesPerHunk <= 0
+  ) {
+    addError(
+      errors,
+      'diff.smart.maxRemovedLinesPerHunk',
+      'maxRemovedLinesPerHunk must be positive.',
+    );
+  }
+
+  if (!isProviderName(config.metadata.provider)) {
+    addError(errors, 'metadata.provider', 'provider must be auto, modelsdev, or local.');
+  }
+  if (!Array.isArray(config.metadata.fallbackOrder)) {
+    addError(errors, 'metadata.fallbackOrder', 'fallbackOrder must be an array.');
+  }
+  if (!isString(config.metadata.providers.modelsdev.url)) {
+    addError(errors, 'metadata.providers.modelsdev.url', 'modelsdev url must be a string.');
+  }
+  if (!isNumber(config.metadata.providers.modelsdev.cacheTtlHours)) {
+    addError(
+      errors,
+      'metadata.providers.modelsdev.cacheTtlHours',
+      'cacheTtlHours must be a number.',
+    );
+  }
+  if (!isString(config.metadata.providers.local.path)) {
+    addError(errors, 'metadata.providers.local.path', 'local path must be a string.');
+  }
+
+  return { valid: errors.length === 0, errors };
+};

package/src/git/commit.ts

@@ -0,0 +1,17 @@
+import { exec } from '../util/exec.js';
+
+export const commitMessage = async (
+  subject: string,
+  body: string,
+  extraArgs: string[] = [],
+  cwd?: string,
+): Promise<void> => {
+  const args = ['git', 'commit', '-m', subject];
+  if (body && body.trim().length > 0) {
+    args.push('-m', body.trim());
+  }
+  if (extraArgs.length > 0) {
+    args.push(...extraArgs);
+  }
+  await exec(args, { cwd });
+};

package/src/git/diff.ts

@@ -0,0 +1,89 @@
+import type { DiffMode } from '../config/types.js';
+import { exec } from '../util/exec.js';
+
+export interface DiffOptions {
+  mode: DiffMode;
+  cwd?: string;
+  compact?: boolean;
+}
+
+const diffBaseArgs = (mode: DiffMode): string[] => {
+  if (mode === 'staged') {
+    return ['diff', '--cached'];
+  }
+  return ['diff'];
+};
+
+export const getDiff = async ({ mode, cwd, compact }: DiffOptions): Promise<string> => {
+  const args = diffBaseArgs(mode);
+  if (compact) {
+    args.push(
+      '--unified=0',
+      '--no-color',
+      '--no-ext-diff',
+      '--diff-algorithm=histogram',
+      '--no-prefix',
+    );
+  } else {
+    args.push('--no-color');
+  }
+  const result = await exec(['git', ...args], { cwd });
+  return result.stdout;
+};
+
+export const getFileList = async ({ mode, cwd }: DiffOptions): Promise<string[]> => {
+  const args = diffBaseArgs(mode);
+  args.push('--name-only');
+  const result = await exec(['git', ...args], { cwd });
+  return result.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+};
+
+const parseNumstat = (
+  raw: string,
+): Map<string, { added: number | null; removed: number | null }> => {
+  const map = new Map<string, { added: number | null; removed: number | null }>();
+  const lines = raw.split(/\r?\n/).filter(Boolean);
+  for (const line of lines) {
+    const [addedRaw, removedRaw, ...pathParts] = line.split('\t');
+    const filePath = pathParts.join('\t');
+    const added = addedRaw === '-' ? null : Number(addedRaw);
+    const removed = removedRaw === '-' ? null : Number(removedRaw);
+    map.set(filePath, {
+      added: Number.isFinite(added) ? added : null,
+      removed: Number.isFinite(removed) ? removed : null,
+    });
+  }
+  return map;
+};
+
+export const getFileSummary = async ({ mode, cwd }: DiffOptions): Promise<string> => {
+  const baseArgs = diffBaseArgs(mode);
+  const [nameStatus, numstat] = await Promise.all([
+    exec(['git', ...baseArgs, '--name-status'], { cwd }),
+    exec(['git', ...baseArgs, '--numstat'], { cwd }),
+  ]);
+
+  const numstatMap = parseNumstat(numstat.stdout);
+  const lines = nameStatus.stdout.split(/\r?\n/).filter(Boolean);
+
+  const summaryLines = lines.map((line) => {
+    const parts = line.split('\t');
+    const status = parts[0] ?? '';
+    const pathPart = parts.length > 2 ? `${parts[1]} -> ${parts[2]}` : (parts[1] ?? '');
+    const numstatEntry =
+      numstatMap.get(parts[2] ?? '') ??
+      numstatMap.get(parts[1] ?? '') ??
+      numstatMap.get(pathPart) ??
+      null;
+    const added = numstatEntry?.added ?? null;
+    const removed = numstatEntry?.removed ?? null;
+    const addedText = added === null ? '?' : String(added);
+    const removedText = removed === null ? '?' : String(removed);
+    return `${status} ${pathPart} (+${addedText} -${removedText})`.trim();
+  });
+
+  return summaryLines.join('\n');
+};

package/src/git/repo.ts

@@ -0,0 +1,10 @@
+import { exec } from '../util/exec.js';
+
+export const getRepoRoot = async (): Promise<string | null> => {
+  try {
+    const result = await exec(['git', 'rev-parse', '--show-toplevel']);
+    return result.stdout.trim() || null;
+  } catch {
+    return null;
+  }
+};

package/src/index.ts

@@ -0,0 +1,207 @@
+#!/usr/bin/env bun
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+import yargs from 'yargs/yargs';
+import { hideBin } from 'yargs/helpers';
+import type { Argv } from 'yargs';
+import { runDefaultCommand } from './commands/default.js';
+import { runAuthLogin, runAuthLogout, runAuthStatus } from './commands/auth.js';
+import { runConfigInit, runConfigPrint, runConfigValidate } from './commands/config.js';
+import { runModelsInfo, runModelsSearch } from './commands/models.js';
+import { setVerbosity } from './util/logger.js';
+
+type DefaultArgs = {
+  yes: boolean;
+  'dry-run': boolean;
+  all: boolean;
+  unstaged: boolean;
+  commit: boolean;
+  model?: string;
+  format?: 'conventional' | 'freeform';
+  lang?: string;
+  'no-body': boolean;
+  verbose: number;
+  '--'?: string[];
+};
+
+type AuthArgs = {
+  'env-key'?: string;
+  token?: string;
+};
+
+type ModelsSearchArgs = {
+  query?: string;
+  maxItems?: number;
+};
+
+type ModelsInfoArgs = {
+  modelId: string;
+};
+
+const cli = (yargs(hideBin(process.argv)) as Argv<DefaultArgs>)
+  .scriptName('zencommit')
+  .parserConfiguration({ 'populate--': true })
+  .option('verbose', {
+    alias: 'v',
+    count: true,
+    default: 0,
+    describe: 'Increase verbosity (-v, -vv, -vvv)',
+  })
+  .middleware((argv) => {
+    const verboseCount = typeof argv.verbose === 'number' ? (argv.verbose as number) : 0;
+    setVerbosity(verboseCount);
+  })
+  .command(
+    '$0',
+    'Generate commit message',
+    (yargsBuilder) =>
+      yargsBuilder
+        .option('yes', {
+          type: 'boolean',
+          default: false,
+          describe: 'Skip confirmation and commit',
+        })
+        .option('dry-run', {
+          type: 'boolean',
+          default: false,
+          describe: 'Do not commit; print output',
+        })
+        .option('all', {
+          type: 'boolean',
+          default: false,
+          describe: 'Stage all changes before generating',
+        })
+        .option('unstaged', { type: 'boolean', default: false, describe: 'Use unstaged diff' })
+        .option('commit', {
+          type: 'boolean',
+          default: false,
+          describe: 'Allow committing with --unstaged',
+        })
+        .option('model', { type: 'string', describe: 'Override model id' })
+        .option('format', {
+          type: 'string',
+          choices: ['conventional', 'freeform'] as const,
+          describe: 'Commit style',
+        })
+        .option('lang', { type: 'string', describe: 'Commit language' })
+        .option('no-body', { type: 'boolean', default: false, describe: 'Subject only' }),
+    async (argv: DefaultArgs) => {
+      await runDefaultCommand({
+        yes: argv.yes,
+        dryRun: argv['dry-run'],
+        all: argv.all,
+        unstaged: argv.unstaged,
+        commit: argv.commit,
+        model: argv.model,
+        format: argv.format,
+        lang: argv.lang,
+        noBody: argv['no-body'],
+        verbose: argv.verbose,
+        '--': argv['--'],
+      });
+    },
+  )
+  .command(
+    'auth',
+    'Manage credentials',
+    (yargsBuilder) =>
+      yargsBuilder
+        .command(
+          'login',
+          'Store an API key in Bun secrets',
+          (sub) =>
+            sub
+              .option('env-key', { type: 'string', describe: 'Environment key name' })
+              .option('token', { type: 'string', describe: 'Secret token value' }),
+          async (argv: AuthArgs) => {
+            await runAuthLogin({ envKey: argv['env-key'], token: argv.token });
+          },
+        )
+        .command(
+          'logout',
+          'Remove an API key from Bun secrets',
+          (sub) => sub.option('env-key', { type: 'string', describe: 'Environment key name' }),
+          async (argv: AuthArgs) => {
+            await runAuthLogout({ envKey: argv['env-key'] });
+          },
+        )
+        .command(
+          'status',
+          'Show stored credentials',
+          () => {},
+          async () => {
+            await runAuthStatus();
+          },
+        )
+        .demandCommand(1, 'Specify a subcommand'),
+    () => {},
+  )
+  .command(
+    'config',
+    'Configuration commands',
+    (yargsBuilder) =>
+      yargsBuilder
+        .command(
+          'print',
+          'Print resolved config',
+          () => {},
+          async () => {
+            await runConfigPrint();
+          },
+        )
+        .command(
+          'init',
+          'Write a starter config file',
+          () => {},
+          async () => {
+            await runConfigInit();
+          },
+        )
+        .command(
+          'validate',
+          'Validate resolved config',
+          () => {},
+          async () => {
+            await runConfigValidate();
+          },
+        )
+        .demandCommand(1, 'Specify a subcommand'),
+    () => {},
+  )
+  .command(
+    'models',
+    'Model metadata commands',
+    (yargsBuilder) =>
+      yargsBuilder
+        .command(
+          'search [query]',
+          'Search models',
+          (sub) =>
+            sub
+              .positional('query', { type: 'string' })
+              .option('max-items', {
+                type: 'number',
+                default: 10,
+                describe: 'Max items to display in autocomplete',
+              }),
+          async (argv: ModelsSearchArgs) => {
+            await runModelsSearch(argv.query, argv.maxItems ?? 10);
+          },
+        )
+        .command(
+          'info <modelId>',
+          'Show model info',
+          (sub) => sub.positional('modelId', { type: 'string', demandOption: true }),
+          async (argv: ModelsInfoArgs) => {
+            await runModelsInfo(argv.modelId);
+          },
+        )
+        .demandCommand(1, 'Specify a subcommand'),
+    () => {},
+  )
+  .strict()
+  .help();
+
+await cli.parse();