zencommit 0.1.0

package/src/commands/default.ts

@@ -0,0 +1,322 @@
+import { ConfigLoadError, resolveConfig, resolveConfigWithSources } from '../config/load.js';
+import { validateConfig } from '../config/validate.js';
+import type { CommitStyle, DiffMode, ResolvedConfig } from '../config/types.js';
+import { createMetadataResolver } from '../metadata/index.js';
+import { getRepoRoot } from '../git/repo.js';
+import { getDiff, getFileList, getFileSummary } from '../git/diff.js';
+import { commitMessage } from '../git/commit.js';
+import { buildPrompt, buildPromptWithoutDiff } from '../llm/prompt.js';
+import { computeTokenBudget, countTokens, getEncodingForModel } from '../llm/tokens.js';
+import { truncateDiffByFile, truncateDiffSmart } from '../llm/truncate.js';
+import { generateCommitMessage } from '../llm/generate.js';
+import { confirmCommit } from '../ui/prompts.js';
+import { openEditor } from '../ui/editor.js';
+import { exec, ExecError } from '../util/exec.js';
+import yoctoSpinner from 'yocto-spinner';
+import { getVerbosity, logBlock, logJson, logVerbose, setVerbosity } from '../util/logger.js';
+import { redactObject } from '../util/redact.js';
+
+const DEFAULT_MAX_SUBJECT_CHARS = 72;
+
+export interface DefaultCommandArgs {
+  yes?: boolean;
+  dryRun?: boolean;
+  all?: boolean;
+  unstaged?: boolean;
+  commit?: boolean;
+  model?: string;
+  format?: CommitStyle;
+  lang?: string;
+  noBody?: boolean;
+  verbose?: number;
+  '--'?: string[];
+}
+
+const applyOverrides = (config: ResolvedConfig, args: DefaultCommandArgs): ResolvedConfig => {
+  const updated = { ...config };
+  if (args.model) {
+    updated.ai = { ...updated.ai, model: args.model };
+  }
+  if (args.format) {
+    updated.commit = { ...updated.commit, style: args.format };
+  }
+  if (args.lang) {
+    updated.commit = { ...updated.commit, language: args.lang };
+  }
+  if (args.noBody) {
+    updated.commit = { ...updated.commit, includeBody: false };
+  }
+  return updated;
+};
+
+const resolveDiffMode = (config: ResolvedConfig, args: DefaultCommandArgs): DiffMode => {
+  if (args.unstaged) {
+    return 'unstaged';
+  }
+  if (args.all) {
+    return 'staged';
+  }
+  return config.git.diffMode;
+};
+
+const maybeAutoStage = async (shouldStage: boolean, cwd?: string): Promise<void> => {
+  if (!shouldStage) {
+    return;
+  }
+  await exec(['git', 'add', '-A'], { cwd });
+};
+
+const formatPreview = (subject: string, body: string): string => {
+  if (body.trim().length === 0) {
+    return subject.trim();
+  }
+  return `${subject.trim()}\n\n${body.trim()}`;
+};
+
+const parseEditedMessage = (text: string): { subject: string; body: string } => {
+  const lines = text.split(/\r?\n/);
+  const subject = lines.shift() ?? '';
+  const body = lines.join('\n').trim();
+  return { subject: subject.trim(), body };
+};
+
+export const runDefaultCommand = async (args: DefaultCommandArgs): Promise<void> => {
+  try {
+    if (typeof args.verbose === 'number') {
+      setVerbosity(args.verbose);
+    }
+    const repoRoot = await getRepoRoot();
+    if (!repoRoot) {
+      console.error('Not inside a git repository.');
+      process.exit(3);
+    }
+    logVerbose(1, `repo root: ${repoRoot}`);
+
+    let config: ResolvedConfig;
+    try {
+      if (getVerbosity() >= 1) {
+        const resolved = await resolveConfigWithSources(repoRoot);
+        config = resolved.config;
+        logJson(1, 'config sources', resolved.sourceMap);
+      } else {
+        config = await resolveConfig(repoRoot);
+      }
+    } catch (error) {
+      if (error instanceof ConfigLoadError) {
+        console.error(error.message);
+        process.exit(2);
+      }
+      throw error;
+    }
+    if (getVerbosity() >= 2) {
+      logJson(2, 'resolved config', redactObject(config));
+    }
+    const validation = validateConfig(config);
+    if (!validation.valid) {
+      console.error('Config validation failed:');
+      validation.errors.forEach((error) => {
+        console.error(`- ${error.path}: ${error.message}`);
+      });
+      process.exit(2);
+    }
+
+    config = applyOverrides(config, args);
+    if (getVerbosity() >= 2) {
+      logJson(2, 'cli overrides', {
+        model: args.model,
+        format: args.format,
+        lang: args.lang,
+        noBody: args.noBody ?? false,
+      });
+    }
+    const requestedDiffMode = resolveDiffMode(config, args);
+    const effectiveDiffMode: DiffMode = requestedDiffMode === 'all' ? 'staged' : requestedDiffMode;
+    const autoStage = args.all || config.git.autoStage || requestedDiffMode === 'all';
+    logVerbose(
+      1,
+      `diff mode: requested=${requestedDiffMode} effective=${effectiveDiffMode} autoStage=${autoStage}`,
+    );
+
+    if (autoStage && effectiveDiffMode !== 'unstaged') {
+      await maybeAutoStage(true, repoRoot);
+    }
+
+    const useSmart = config.diff.truncateStrategy === 'smart';
+    const diffText = await getDiff({ mode: effectiveDiffMode, cwd: repoRoot, compact: useSmart });
+    if (getVerbosity() >= 2) {
+      const diffLines = diffText ? diffText.split(/\r?\n/).length : 0;
+      logVerbose(2, `diff length: ${diffText.length} chars, ${diffLines} lines`);
+    }
+
+    if (!diffText.trim()) {
+      console.error('No diff to summarize.');
+      process.exit(3);
+    }
+
+    const fileList = config.diff.includeFileList
+      ? (await getFileList({ mode: effectiveDiffMode, cwd: repoRoot }))
+          .slice(0, config.diff.maxFiles)
+          .join('\n')
+      : '';
+    if (getVerbosity() >= 2) {
+      const fileCount = fileList ? fileList.split(/\r?\n/).length : 0;
+      logVerbose(2, `file list: ${fileCount} files`);
+    }
+
+    const metadataResolver = createMetadataResolver(config.metadata, repoRoot);
+    const modelMetadata = await metadataResolver.getModel(config.ai.model);
+
+    const limits = modelMetadata?.limits ?? ({ context: 8000, input: 8000, output: null } as const);
+
+    if (!modelMetadata) {
+      console.warn('Model metadata not found. Using conservative token limits.');
+    } else if (getVerbosity() >= 2) {
+      logJson(2, 'model metadata', modelMetadata);
+    }
+
+    const encoding = getEncodingForModel(config.ai.model);
+    const promptInput = {
+      style: config.commit.style,
+      language: config.commit.language,
+      includeBody: config.commit.includeBody,
+      emoji: config.commit.emoji,
+      maxSubjectChars: DEFAULT_MAX_SUBJECT_CHARS,
+      fileList,
+      diffText: '',
+    };
+
+    const promptWithoutDiff = await buildPromptWithoutDiff(promptInput);
+    const overheadTokens = countTokens(
+      `${promptWithoutDiff.system}\n${promptWithoutDiff.user}`,
+      encoding,
+    );
+
+    const budget = computeTokenBudget(limits, config.ai.maxOutputTokens, overheadTokens);
+    if (getVerbosity() >= 2) {
+      logJson(2, 'token budget', budget);
+    }
+
+    let truncatedText = '';
+    if (useSmart) {
+      const fileSummary = await getFileSummary({ mode: effectiveDiffMode, cwd: repoRoot });
+      const truncated = truncateDiffSmart(
+        fileSummary,
+        diffText,
+        budget.availableTokens,
+        config.diff,
+        encoding,
+      );
+      truncatedText = truncated.text;
+      if (getVerbosity() >= 2) {
+        logVerbose(2, `truncation: mode=${truncated.mode} usedTokens=${truncated.usedTokens}`);
+      }
+    } else if (budget.availableTokens <= 0) {
+      const fileSummary = await getFileSummary({ mode: effectiveDiffMode, cwd: repoRoot });
+      truncatedText = fileSummary.trim() ? `File summary:\\n${fileSummary.trim()}` : fileList;
+    } else {
+      const truncated = truncateDiffByFile(diffText, budget.availableTokens, encoding);
+      truncatedText = truncated.text;
+      if (getVerbosity() >= 2) {
+        logVerbose(2, `truncation: mode=${truncated.mode} usedTokens=${truncated.usedTokens}`);
+      }
+    }
+
+    encoding.free();
+
+    const prompt = await buildPrompt({ ...promptInput, diffText: truncatedText });
+    if (getVerbosity() >= 3) {
+      logBlock(3, 'prompt system', prompt.system);
+      logBlock(3, 'prompt user', prompt.user);
+    }
+    const spinner = process.stderr.isTTY
+      ? yoctoSpinner({ text: 'Generating commit message...' }).start()
+      : null;
+    let message: { subject: string; body: string };
+    try {
+      if (getVerbosity() >= 2) {
+        logJson(2, 'llm request', {
+          modelId: config.ai.model,
+          temperature: config.ai.temperature,
+          maxOutputTokens: Math.min(config.ai.maxOutputTokens, budget.outputTokens),
+          timeoutMs: config.ai.timeoutMs,
+          style: config.commit.style,
+        });
+      }
+      message = await generateCommitMessage({
+        modelId: config.ai.model,
+        system: prompt.system,
+        user: prompt.user,
+        temperature: config.ai.temperature,
+        maxOutputTokens: Math.min(config.ai.maxOutputTokens, budget.outputTokens),
+        timeoutMs: config.ai.timeoutMs,
+        maxSubjectChars: DEFAULT_MAX_SUBJECT_CHARS,
+        style: config.commit.style,
+        openaiCompatible: config.ai.openaiCompatible,
+      });
+      spinner?.success('Generated commit message.');
+      if (getVerbosity() >= 2) {
+        logJson(2, 'llm response', message);
+      }
+    } catch (error) {
+      spinner?.error('Failed to generate commit message.');
+      throw error;
+    }
+
+    if (!config.commit.includeBody) {
+      message = { ...message, body: '' };
+    }
+
+    console.log('\n' + formatPreview(message.subject, message.body) + '\n');
+
+    const extraArgs = args['--'] ?? [];
+    const allowCommit = effectiveDiffMode !== 'unstaged' || args.commit;
+    const shouldCommit = allowCommit && !args.dryRun;
+    if (getVerbosity() >= 1) {
+      logJson(1, 'commit decision', {
+        allowCommit,
+        shouldCommit,
+        extraArgs,
+        dryRun: args.dryRun ?? false,
+      });
+    }
+
+    if (!shouldCommit) {
+      if (effectiveDiffMode === 'unstaged' && !args.commit) {
+        console.warn('Unstaged diff selected; skipping commit unless --commit is provided.');
+      }
+      process.exit(0);
+    }
+
+    const skipConfirm = args.yes || !config.git.confirmBeforeCommit;
+    if (getVerbosity() >= 2) {
+      logVerbose(2, `commit confirmation: ${skipConfirm ? 'skipped' : 'prompted'}`);
+    }
+    if (!skipConfirm) {
+      const action = await confirmCommit('Commit with this message?');
+      if (action === 'cancel') {
+        process.exit(0);
+      }
+      if (action === 'edit') {
+        logVerbose(2, 'commit message: opening editor');
+        const edited = await openEditor(formatPreview(message.subject, message.body));
+        const parsed = parseEditedMessage(edited);
+        message = { subject: parsed.subject, body: parsed.body };
+      }
+    }
+
+    await commitMessage(message.subject, message.body, extraArgs, repoRoot);
+  } catch (error) {
+    if (error instanceof ExecError) {
+      console.error(error.stderr || error.message);
+      process.exit(3);
+    }
+    const message = (error as Error).message ?? 'Unknown error.';
+    if (/API key/i.test(message)) {
+      console.error(message);
+      console.error('Run `zencommit auth login` to store credentials.');
+      process.exit(2);
+    }
+    console.error(message);
+    process.exit(4);
+  }
+};

package/src/commands/models.ts

@@ -0,0 +1,67 @@
+import { createMetadataResolver } from '../metadata/index.js';
+import { ConfigLoadError, resolveConfig } from '../config/load.js';
+import { getRepoRoot } from '../git/repo.js';
+import { promptForModelSelection } from '../ui/prompts.js';
+import { logVerbose } from '../util/logger.js';
+
+export const runModelsSearch = async (query?: string, maxItems = 10): Promise<void> => {
+  try {
+    const repoRoot = await getRepoRoot();
+    logVerbose(1, `models search: repo root ${repoRoot ?? 'unknown'}`);
+    const config = await resolveConfig(repoRoot);
+    const resolver = createMetadataResolver(config.metadata, repoRoot);
+    const list = resolver.list ? await resolver.list() : [];
+    const models = list.length > 0 ? list : query ? await resolver.search(query) : [];
+    logVerbose(2, `models search: candidates=${models.length}`);
+    if (models.length === 0) {
+      console.log('No models found.');
+      return;
+    }
+
+    const selectedId = await promptForModelSelection(
+      models.map((model) => ({ id: model.id, name: model.name })),
+      query,
+      maxItems,
+    );
+    if (!selectedId) {
+      return;
+    }
+
+    const selected =
+      models.find((model) => model.id === selectedId) ?? (await resolver.getModel(selectedId));
+    if (selected) {
+      console.log(JSON.stringify(selected, null, 2));
+    } else {
+      console.log(selectedId);
+    }
+  } catch (error) {
+    if (error instanceof ConfigLoadError) {
+      console.error(error.message);
+      process.exit(2);
+    }
+    throw error;
+  }
+};
+
+export const runModelsInfo = async (modelId: string): Promise<void> => {
+  try {
+    const repoRoot = await getRepoRoot();
+    logVerbose(1, `models info: repo root ${repoRoot ?? 'unknown'}`);
+    const config = await resolveConfig(repoRoot);
+    const resolver = createMetadataResolver(config.metadata, repoRoot);
+    const model = await resolver.getModel(modelId);
+    if (!model) {
+      console.error(`Model not found: ${modelId}`);
+      console.error('Try switching metadata providers or providing a local metadata file.');
+      process.exit(2);
+    }
+
+    console.log(JSON.stringify(model, null, 2));
+  } catch (error) {
+    if (error instanceof ConfigLoadError) {
+      console.error(error.message);
+      process.exit(2);
+    }
+    throw error;
+  }
+};

package/src/config/load.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { resolveConfig } from './load.js';
+
+const writeJson = async (filePath: string, data: unknown) => {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, JSON.stringify(data), 'utf8');
+};
+
+const withTempDir = async (fn: (dir: string) => Promise<void>) => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'zencommit-test-'));
+  await fn(dir);
+};
+
+describe('resolveConfig precedence', () => {
+  it('merges config sources in order', async () => {
+    const originalEnv = { ...process.env };
+    await withTempDir(async (dir) => {
+      const repoRoot = path.join(dir, 'repo');
+      await fs.mkdir(repoRoot, { recursive: true });
+
+      const globalRoot = path.join(dir, 'global');
+      process.env.XDG_CONFIG_HOME = globalRoot;
+
+      const globalConfigPath = path.join(globalRoot, 'zencommit', 'config.json');
+      await writeJson(globalConfigPath, { commit: { style: 'freeform' } });
+
+      const customPath = path.join(dir, 'custom.json');
+      await writeJson(customPath, { ai: { model: 'openai/test-model' } });
+      process.env.ZENCOMMIT_CONFIG = customPath;
+
+      const projectPath = path.join(repoRoot, 'zencommit.json');
+      await writeJson(projectPath, { commit: { language: 'es' } });
+
+      process.env.ZENCOMMIT_CONFIG_CONTENT = JSON.stringify({ ai: { temperature: 0.9 } });
+
+      const config = await resolveConfig(repoRoot);
+      expect(config.commit.style).toBe('freeform');
+      expect(config.ai.model).toBe('openai/test-model');
+      expect(config.commit.language).toBe('es');
+      expect(config.ai.temperature).toBe(0.9);
+    });
+    process.env = originalEnv;
+  });
+});

package/src/config/load.ts

@@ -0,0 +1,118 @@
+import path from 'node:path';
+import { deepMerge } from './merge.js';
+import type { ResolvedConfig } from './types.js';
+import { defaultConfig } from './types.js';
+import { getConfigRoot, readJsonFile, resolvePath } from '../util/fs.js';
+
+export type ConfigSourceName = 'global' | 'custom' | 'project' | 'inline';
+
+export interface ConfigSource {
+  name: ConfigSourceName;
+  path?: string;
+  data: unknown;
+}
+
+export class ConfigLoadError extends Error {
+  source: ConfigSourceName | 'inline' | 'unknown';
+  path?: string;
+
+  constructor(message: string, source: ConfigSourceName | 'inline' | 'unknown', path?: string) {
+    super(message);
+    this.name = 'ConfigLoadError';
+    this.source = source;
+    this.path = path;
+  }
+}
+
+const readConfigFile = async (
+  filePath: string,
+  source: ConfigSourceName,
+): Promise<Record<string, unknown> | null> => {
+  try {
+    return await readJsonFile<Record<string, unknown>>(filePath);
+  } catch (error) {
+    throw new ConfigLoadError(
+      `Failed to parse ${source} config at ${filePath}: ${(error as Error).message}`,
+      source,
+      filePath,
+    );
+  }
+};
+
+export const getGlobalConfigPath = (): string =>
+  path.join(getConfigRoot(), 'zencommit', 'config.json');
+
+export const getProjectConfigPath = (repoRoot: string | null): string | null => {
+  if (!repoRoot) {
+    return null;
+  }
+  return path.join(repoRoot, 'zencommit.json');
+};
+
+export const loadConfigSources = async (repoRoot: string | null): Promise<ConfigSource[]> => {
+  const sources: ConfigSource[] = [];
+
+  const globalPath = getGlobalConfigPath();
+  const globalConfig = await readConfigFile(globalPath, 'global');
+  if (globalConfig) {
+    sources.push({ name: 'global', path: globalPath, data: globalConfig });
+  }
+
+  const customPathEnv = process.env.ZENCOMMIT_CONFIG;
+  if (customPathEnv) {
+    const resolvedPath = resolvePath(customPathEnv, repoRoot ?? process.cwd());
+    const customConfig = await readConfigFile(resolvedPath, 'custom');
+    if (customConfig) {
+      sources.push({ name: 'custom', path: resolvedPath, data: customConfig });
+    }
+  }
+
+  const projectPath = getProjectConfigPath(repoRoot);
+  if (projectPath) {
+    const projectConfig = await readConfigFile(projectPath, 'project');
+    if (projectConfig) {
+      sources.push({ name: 'project', path: projectPath, data: projectConfig });
+    }
+  }
+
+  const inlineContent = process.env.ZENCOMMIT_CONFIG_CONTENT;
+  if (inlineContent) {
+    try {
+      const inlineConfig = JSON.parse(inlineContent) as Record<string, unknown>;
+      sources.push({ name: 'inline', data: inlineConfig });
+    } catch (error) {
+      throw new ConfigLoadError(
+        `Invalid JSON in ZENCOMMIT_CONFIG_CONTENT: ${(error as Error).message}`,
+        'inline',
+      );
+    }
+  }
+
+  return sources;
+};
+
+export const resolveConfig = async (repoRoot: string | null): Promise<ResolvedConfig> => {
+  const sources = await loadConfigSources(repoRoot);
+  return sources.reduce(
+    (config, source) => deepMerge(config, source.data as Partial<ResolvedConfig>),
+    defaultConfig,
+  );
+};
+
+export const resolveConfigWithSources = async (
+  repoRoot: string | null,
+): Promise<{ config: ResolvedConfig; sourceMap: Record<string, ConfigSourceName> }> => {
+  const sources = await loadConfigSources(repoRoot);
+  let config = defaultConfig;
+  const sourceMap: Record<string, ConfigSourceName> = {};
+
+  for (const source of sources) {
+    const data = source.data as Record<string, unknown>;
+    for (const key of Object.keys(data)) {
+      sourceMap[key] = source.name;
+    }
+    config = deepMerge(config, data as Partial<ResolvedConfig>);
+  }
+
+  return { config, sourceMap };
+};

package/src/config/merge.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+import { deepMerge } from './merge.js';
+
+describe('deepMerge', () => {
+  it('merges nested objects', () => {
+    const base = { a: { b: 1, c: 2 }, d: 3 };
+    const override = { a: { b: 9 } };
+    const result = deepMerge(base, override);
+    expect(result).toEqual({ a: { b: 9, c: 2 }, d: 3 });
+  });
+
+  it('replaces arrays', () => {
+    const base = { items: [1, 2, 3] };
+    const override = { items: [9] };
+    const result = deepMerge(base, override);
+    expect(result).toEqual({ items: [9] });
+  });
+
+  it('replaces scalars', () => {
+    const base = { value: 1 };
+    const override = { value: 2 };
+    const result = deepMerge(base, override);
+    expect(result).toEqual({ value: 2 });
+  });
+});

package/src/config/merge.ts

@@ -0,0 +1,30 @@
+const isPlainObject = (value: unknown): value is Record<string, unknown> => {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value) as object | null;
+  return proto === Object.prototype || proto === null;
+};
+
+export const deepMerge = <T>(base: T, override: Partial<T>): T => {
+  if (Array.isArray(base) || Array.isArray(override)) {
+    return (override ?? base) as T;
+  }
+  if (!isPlainObject(base) || !isPlainObject(override)) {
+    return (override ?? base) as T;
+  }
+
+  const result: Record<string, unknown> = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    const baseValue = (base as Record<string, unknown>)[key];
+    if (Array.isArray(value)) {
+      result[key] = value;
+    } else if (isPlainObject(value) && isPlainObject(baseValue)) {
+      result[key] = deepMerge(baseValue, value);
+    } else if (value !== undefined) {
+      result[key] = value;
+    }
+  }
+
+  return result as T;
+};