@ksw8954/git-ai-commit 1.1.7 → 1.2.0

package/src/commands/ai.ts

@@ -1,9 +1,10 @@
 import OpenAI from 'openai';
 import { type ChatCompletionCreateParamsNonStreaming } from 'openai/resources/chat/completions';
+import { GoogleGenAI } from '@google/genai';
 import { generateCommitPrompt } from '../prompts/commit';
 import { generateTagPrompt } from '../prompts/tag';
 import { generatePullRequestPrompt } from '../prompts/pr';
-import { SupportedLanguage } from './config';
+import { SupportedLanguage, AIMode } from './config';
 
 export type ReasoningEffort = 'minimal' | 'low' | 'medium' | 'high';
 
@@ -15,6 +16,8 @@ export interface AIServiceConfig {
   reasoningEffort?: ReasoningEffort;
   language?: SupportedLanguage;
   verbose?: boolean;
+  mode?: AIMode;
+  maxCompletionTokens?: number;
 }
 
 export interface CommitGenerationResult {
@@ -36,23 +39,35 @@ export interface PullRequestGenerationResult {
 }
 
 export class AIService {
-  private openai: OpenAI;
+  private openai: OpenAI | null = null;
+  private gemini: GoogleGenAI | null = null;
+  private mode: AIMode;
   private model: string;
   private fallbackModel?: string;
   private reasoningEffort?: ReasoningEffort;
   private language: SupportedLanguage;
   private verbose: boolean;
+  private maxCompletionTokens?: number;
 
   constructor(config: AIServiceConfig) {
-    this.openai = new OpenAI({
-      apiKey: config.apiKey,
-      baseURL: config.baseURL
-    });
-    this.model = config.model || 'zai-org/GLM-4.5-FP8';
+    this.mode = config.mode || 'custom';
+
+    if (this.mode === 'gemini') {
+      this.gemini = new GoogleGenAI({ apiKey: config.apiKey });
+      this.model = config.model || 'gemini-2.0-flash';
+    } else {
+      this.openai = new OpenAI({
+        apiKey: config.apiKey,
+        baseURL: config.baseURL
+      });
+      this.model = config.model || 'zai-org/GLM-4.5-FP8';
+    }
+
     this.fallbackModel = config.fallbackModel;
     this.reasoningEffort = config.reasoningEffort;
     this.language = config.language || 'ko';
     this.verbose = config.verbose ?? true;
+    this.maxCompletionTokens = config.maxCompletionTokens;
   }
 
   private debugLog(...args: unknown[]): void {
@@ -157,10 +172,110 @@ export class AIService {
     return `${seconds}s`;
   }
 
+  private async createGeminiStreamingCompletion(
+    request: ChatCompletionCreateParamsNonStreaming
+  ): Promise<string> {
+    if (!this.gemini) throw new Error('Gemini client not initialized');
+
+    let waitingTimer: ReturnType<typeof setInterval> | null = null;
+    const startTime = Date.now();
+    let frameIndex = 0;
+
+    try {
+      if (this.verbose) {
+        waitingTimer = setInterval(() => {
+          const frame = this.spinnerFrames[frameIndex++ % this.spinnerFrames.length];
+          const elapsed = this.formatElapsed(Date.now() - startTime);
+          process.stdout.write(`\r${frame} Waiting for response... (${elapsed})`);
+        }, 100);
+      }
+
+      const systemMessage = request.messages.find(m => m.role === 'system');
+      const userMessages = request.messages.filter(m => m.role !== 'system');
+      const contents = userMessages.map(m => ({
+        role: m.role === 'assistant' ? 'model' as const : 'user' as const,
+        parts: [{ text: typeof m.content === 'string' ? m.content : '' }]
+      }));
+
+      const maxTokens = (request as unknown as Record<string, unknown>).max_completion_tokens as number | undefined
+        ?? request.max_tokens
+        ?? 3000;
+
+      const stream = await this.gemini.models.generateContentStream({
+        model: this.model,
+        contents,
+        config: {
+          ...(systemMessage ? { systemInstruction: typeof systemMessage.content === 'string' ? systemMessage.content : '' } : {}),
+          maxOutputTokens: maxTokens,
+        }
+      });
+
+      const contentChunks: string[] = [];
+      let chunkCount = 0;
+      let lastChunkUsage: { promptTokenCount?: number; candidatesTokenCount?: number; totalTokenCount?: number } | undefined;
+
+      for await (const chunk of stream) {
+        if (chunk.usageMetadata) {
+          lastChunkUsage = chunk.usageMetadata;
+        }
+
+        const text = chunk.text;
+        if (text) {
+          contentChunks.push(text);
+          chunkCount++;
+
+          if (waitingTimer) {
+            clearInterval(waitingTimer);
+            waitingTimer = null;
+          }
+
+          if (this.verbose) {
+            const frame = this.spinnerFrames[frameIndex++ % this.spinnerFrames.length];
+            const elapsed = this.formatElapsed(Date.now() - startTime);
+            process.stdout.write(`\r${frame} Streaming... (${chunkCount} chunks, ${elapsed})`);
+          }
+        }
+      }
+
+      if (waitingTimer) {
+        clearInterval(waitingTimer);
+        waitingTimer = null;
+      }
+
+      if (this.verbose) {
+        const elapsed = this.formatElapsed(Date.now() - startTime);
+        if (lastChunkUsage) {
+          const prompt = lastChunkUsage.promptTokenCount ?? 0;
+          const response = lastChunkUsage.candidatesTokenCount ?? 0;
+          process.stdout.write(`\r✅ Complete (response: ${response}, prompt: ${prompt} tokens, ${elapsed})\n`);
+        } else {
+          process.stdout.write(`\r✅ Complete (~${chunkCount} chunks, ${elapsed})\n`);
+        }
+      }
+
+      return contentChunks.join('');
+    } catch (error) {
+      if (waitingTimer) {
+        clearInterval(waitingTimer);
+        waitingTimer = null;
+      }
+      if (this.verbose) {
+        process.stdout.write('\n');
+      }
+      throw error;
+    }
+  }
+
   private async createStreamingCompletion(
     request: ChatCompletionCreateParamsNonStreaming,
     attempt = 0
   ): Promise<string> {
+    if (this.mode === 'gemini') {
+      return this.createGeminiStreamingCompletion(request);
+    }
+
+    if (!this.openai) throw new Error('OpenAI client not initialized');
+
     let waitingTimer: ReturnType<typeof setInterval> | null = null;
 
     try {
@@ -178,23 +293,41 @@ export class AIService {
       const streamParams = {
         ...request,
         stream: true as const,
+        stream_options: { include_usage: true },
         ...(this.reasoningEffort ? { reasoning_effort: this.reasoningEffort } : {})
       };
 
       const stream = await this.openai.chat.completions.create(streamParams);
 
       const contentChunks: string[] = [];
-      let reasoningTokens = 0;
-      let contentTokens = 0;
+      let reasoningChunks = 0;
+      let contentChunksCount = 0;
       let phase: 'waiting' | 'thinking' | 'content' = 'waiting';
+      
+      interface StreamUsage {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        total_tokens?: number;
+        completion_tokens_details?: {
+          reasoning_tokens?: number;
+        };
+      }
+      let finalUsage: StreamUsage | null = null;
 
       for await (const chunk of stream) {
+        const chunkUsage = (chunk as unknown as { usage?: StreamUsage }).usage;
+        if (chunkUsage) {
+          finalUsage = chunkUsage;
+        }
+
         const delta = chunk.choices[0]?.delta;
+        if (!delta) continue;
+        
         const content = delta?.content;
         const reasoning = (delta as Record<string, unknown>)?.reasoning_content as string | undefined;
 
         if (reasoning) {
-          reasoningTokens++;
+          reasoningChunks++;
 
           if (phase === 'waiting' && waitingTimer) {
             clearInterval(waitingTimer);
@@ -205,13 +338,13 @@ export class AIService {
           if (this.verbose && phase === 'thinking') {
             const frame = this.spinnerFrames[frameIndex++ % this.spinnerFrames.length];
             const elapsed = this.formatElapsed(Date.now() - startTime);
-            process.stdout.write(`\r${frame} Thinking... (${reasoningTokens} tokens, ${elapsed})`);
+            process.stdout.write(`\r${frame} Thinking... (${reasoningChunks} chunks, ${elapsed})`);
           }
         }
 
         if (content) {
           contentChunks.push(content);
-          contentTokens++;
+          contentChunksCount++;
 
           if (phase !== 'content') {
             if (waitingTimer) {
@@ -224,7 +357,7 @@ export class AIService {
           if (this.verbose) {
             const frame = this.spinnerFrames[frameIndex++ % this.spinnerFrames.length];
             const elapsed = this.formatElapsed(Date.now() - startTime);
-            process.stdout.write(`\r${frame} Streaming response... (${contentTokens} tokens, ${elapsed})`);
+            process.stdout.write(`\r${frame} Streaming... (${contentChunksCount} chunks, ${elapsed})`);
           }
         }
       }
@@ -235,12 +368,30 @@ export class AIService {
       }
 
       if (this.verbose) {
-        const totalTokens = reasoningTokens + contentTokens;
         const elapsed = this.formatElapsed(Date.now() - startTime);
-        const detail = reasoningTokens > 0
-          ? `${totalTokens} tokens (thinking: ${reasoningTokens}, response: ${contentTokens}), ${elapsed}`
-          : `${contentTokens} tokens, ${elapsed}`;
-        process.stdout.write(`\r✅ Complete (${detail})\n`);
+        
+        if (finalUsage) {
+          const reasoningTokens = finalUsage.completion_tokens_details?.reasoning_tokens ?? 0;
+          const completionTokens = finalUsage.completion_tokens ?? 0;
+          const promptTokens = finalUsage.prompt_tokens ?? 0;
+          
+          // Gemini: completion_tokens is response-only (separate from reasoning)
+          // OpenAI: completion_tokens includes reasoning
+          const responseTokens = reasoningTokens > 0 && completionTokens > reasoningTokens
+            ? completionTokens - reasoningTokens
+            : completionTokens;
+          
+          if (reasoningTokens > 0) {
+            process.stdout.write(`\r✅ Complete (thinking: ${reasoningTokens}, response: ${responseTokens}, prompt: ${promptTokens} tokens, ${elapsed})\n`);
+          } else {
+            process.stdout.write(`\r✅ Complete (response: ${completionTokens}, prompt: ${promptTokens} tokens, ${elapsed})\n`);
+          }
+        } else {
+          const detail = reasoningChunks > 0
+            ? `~${reasoningChunks + contentChunksCount} chunks (thinking: ~${reasoningChunks}, response: ~${contentChunksCount}), ${elapsed}`
+            : `~${contentChunksCount} chunks, ${elapsed}`;
+          process.stdout.write(`\r✅ Complete (${detail})\n`);
+        }
       }
 
       return contentChunks.join('');
@@ -317,7 +468,7 @@ export class AIService {
     try {
       this.debugLog('Sending request to AI API...');
       this.debugLog('Model:', this.model);
-      this.debugLog('Base URL:', this.openai.baseURL);
+      this.debugLog('Base URL:', this.openai?.baseURL ?? 'Gemini native');
       
       const customInstructions = extraInstructions && extraInstructions.trim().length > 0
         ? `Git diff will be provided separately in the user message.\n\n## Additional User Instructions\n${extraInstructions.trim()}`
@@ -339,7 +490,7 @@ export class AIService {
             content: `Git diff:\n${diff}`
           }
         ],
-        max_completion_tokens: 3000
+        max_completion_tokens: this.maxCompletionTokens ?? 1000
       });
 
       let finalMessage = content.trim() || null;
@@ -455,7 +606,7 @@ export class AIService {
     try {
       this.debugLog('Sending request to AI API for tag notes...');
       this.debugLog('Model:', this.model);
-      this.debugLog('Base URL:', this.openai.baseURL);
+      this.debugLog('Base URL:', this.openai?.baseURL ?? 'Gemini native');
 
       const customInstructions = extraInstructions && extraInstructions.trim().length > 0
         ? `${extraInstructions.trim()}`
@@ -483,7 +634,7 @@ export class AIService {
             content: userContent
           }
         ],
-        max_completion_tokens: 3000
+        max_completion_tokens: this.maxCompletionTokens ?? 3000
       });
 
       const finalNotes = content.trim() || null;
@@ -517,7 +668,7 @@ export class AIService {
     try {
       this.debugLog('Sending request to AI API for pull request message...');
       this.debugLog('Model:', this.model);
-      this.debugLog('Base URL:', this.openai.baseURL);
+      this.debugLog('Base URL:', this.openai?.baseURL ?? 'Gemini native');
 
       const content = await this.createStreamingCompletion({
         model: this.model,
@@ -536,7 +687,7 @@ export class AIService {
             content: `Git diff between ${baseBranch} and ${compareBranch}:\n${diff}`
           }
         ],
-        max_completion_tokens: 4000
+        max_completion_tokens: this.maxCompletionTokens ?? 4000
       });
 
       const finalMessage = content.trim() || null;

package/src/commands/commit.ts

@@ -2,7 +2,7 @@ import { Command } from "commander";
 import readline from "readline";
 import fs from "fs";
 import path from "path";
-import { spawn } from "child_process";
+import { spawn, execFileSync } from "child_process";
 import { GitService, GitDiffResult } from "./git";
 import { AIService, AIServiceConfig } from "./ai";
 import { ConfigService } from "./config";
@@ -46,6 +46,16 @@ export class CommitCommand {
       .action(this.handleCommit.bind(this));
   }
 
+  private isCommandAvailable(command: string): boolean {
+    const checker = process.platform === "win32" ? "where" : "which";
+    try {
+      execFileSync(checker, [command], { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
   private async runPreCommitHook(): Promise<void> {
     // 1. Check for npm pre-commit script
     const packageJsonPath = path.resolve(process.cwd(), "package.json");
@@ -88,43 +98,33 @@ export class CommitCommand {
     // 2. Check for .pre-commit-config.yaml (Python/General pre-commit)
     const preCommitConfigPath = path.resolve(process.cwd(), ".pre-commit-config.yaml");
     if (fs.existsSync(preCommitConfigPath)) {
+      if (!this.isCommandAvailable("pre-commit")) {
+        console.warn("⚠️ .pre-commit-config.yaml found but 'pre-commit' is not installed. Skipping hooks.");
+        return;
+      }
+
       console.log("Found .pre-commit-config.yaml, running pre-commit hooks...");
-      
-      try {
-        await new Promise<void>((resolve, reject) => {
-          const child = spawn("pre-commit", ["run"], {
-            stdio: "inherit",
-            shell: true,
-          });
 
-          child.on("close", (code) => {
-            if (code === 0) {
-              console.log("✅ pre-commit hooks passed");
-              resolve();
-            } else {
-              console.error(`❌ pre-commit hooks failed with code ${code}`);
-              reject(new Error(`pre-commit hooks failed with code ${code}`));
-            }
-          });
+      await new Promise<void>((resolve, reject) => {
+        const child = spawn("pre-commit", ["run"], {
+          stdio: "inherit",
+          shell: true,
+        });
 
-          child.on("error", (err) => {
-            // If pre-commit is not installed/found, we might want to warn instead of fail?
-            // But usually 'error' event on spawn (with shell:true) is rare for command not found (it usually exits with 127).
-            // However, if it fails to spawn, we reject.
-            reject(err);
-          });
+        child.on("close", (code) => {
+          if (code === 0) {
+            console.log("✅ pre-commit hooks passed");
+            resolve();
+          } else {
+            console.error(`❌ pre-commit hooks failed with code ${code}`);
+            reject(new Error(`pre-commit hooks failed with code ${code}`));
+          }
         });
-      } catch (error) {
-        // If the error suggests command not found, we might warn.
-        // But since we use shell:true, 'command not found' usually results in exit code 127, which goes to 'close' event.
-        // So we catch the error from the promise rejection above.
-        const msg = error instanceof Error ? error.message : String(error);
-        if (msg.includes("code 127") || msg.includes("ENOENT")) {
-           console.warn("⚠️ 'pre-commit' command not found, skipping hooks despite configuration file presence.");
-           return;
-        }
-        throw error;
-      }
+
+        child.on("error", (err) => {
+          reject(err);
+        });
+      });
     }
   }
 
@@ -165,6 +165,8 @@ export class CommitCommand {
         reasoningEffort: existingConfig.reasoningEffort,
         language: existingConfig.language,
         verbose: !messageOnly,
+        mode: existingConfig.mode,
+        maxCompletionTokens: existingConfig.maxCompletionTokens,
       };
 
       log("Getting staged changes...");
@@ -210,6 +212,10 @@ export class CommitCommand {
         process.exit(1);
       }
 
+
+      if (existingConfig.coAuthor) {
+        aiResult.message = `${aiResult.message}\n\nCo-authored-by: ${existingConfig.coAuthor}`;
+      }
       if (messageOnly) {
         console.log(aiResult.message);
         await LogService.append({

package/src/commands/completion.ts

@@ -33,14 +33,14 @@ _git_ai_commit() {
     local cur prev words cword
     _init_completion || return
 
-    local commands="commit config pr tag history completion"
+    local commands="commit config pr tag history completion hook"
     
     # Global options
     local global_opts="-v --version -h --help"
 
     # Command-specific options
     local commit_opts="-k --api-key -b --base-url --model -m --message-only -p --push --prompt --no-verify"
-    local config_opts="-s --show -l --language --auto-push --no-auto-push -k --api-key -b --base-url -m --model --fallback-model --reasoning-effort --mode"
+    local config_opts="-s --show -l --language --auto-push --no-auto-push -k --api-key -b --base-url -m --model --fallback-model --reasoning-effort --mode --co-author --no-co-author"
     local pr_opts="--base --compare -k --api-key -b --base-url --model"
     local tag_opts="-k --api-key --base-url -m --model --message -t --base-tag --prompt"
     local history_opts="-l --limit --json --clear"
@@ -71,10 +71,10 @@ _git_ai_commit() {
                     return
                     ;;
                 --mode)
-                    COMPREPLY=( \$(compgen -W "custom openai" -- "\${cur}") )
+                    COMPREPLY=( \$(compgen -W "custom openai gemini" -- "\${cur}") )
                     return
                     ;;
-                -k|--api-key|-b|--base-url|-m|--model)
+                -k|--api-key|-b|--base-url|-m|--model|--co-author)
                     return
                     ;;
             esac
@@ -119,6 +119,9 @@ _git_ai_commit() {
         completion)
             COMPREPLY=( \$(compgen -W "bash zsh" -- "\${cur}") )
             ;;
+        hook)
+            COMPREPLY=( \$(compgen -W "install uninstall status" -- "\${cur}") )
+            ;;
     esac
 }
 
@@ -157,6 +160,7 @@ _git-ai-commit() {
                 'tag:Create an annotated git tag with AI-generated notes'
                 'history:Manage git-ai-commit command history'
                 'completion:Generate shell completion scripts'
+                'hook:Manage prepare-commit-msg git hook'
             )
             _describe -t commands 'git-ai-commit commands' commands
             ;;
@@ -190,7 +194,9 @@ _git-ai-commit() {
                         '--base-url[Persist API base URL]:url:' \\
                         '-m[Persist default AI model]:model:' \\
                         '--model[Persist default AI model]:model:' \\
-                        '--mode[Persist AI mode]:mode:(custom openai)'
+                        '--mode[Persist AI mode]:mode:(custom openai gemini)' \\
+                        '--co-author[Set Co-authored-by trailer for commits]:author:' \\
+                        '--no-co-author[Remove Co-authored-by trailer]'
                     ;;
                 pr)
                     _arguments \\
@@ -236,6 +242,10 @@ _git-ai-commit() {
                     _arguments \\
                         '1:shell:(bash zsh)'
                     ;;
+                hook)
+                    _arguments \\
+                        '1:action:(install uninstall status)'
+                    ;;
             esac
             ;;
     esac

package/src/commands/config.ts

@@ -7,15 +7,19 @@ export type SupportedLanguage = 'ko' | 'en';
 
 export type ReasoningEffort = 'minimal' | 'low' | 'medium' | 'high';
 
+export type AIMode = 'custom' | 'openai' | 'gemini';
+
 export interface EnvironmentConfig {
   apiKey?: string;
   baseURL?: string;
   model?: string;
   fallbackModel?: string;
   reasoningEffort?: ReasoningEffort;
-  mode: 'custom' | 'openai';
+  mode: AIMode;
   language: SupportedLanguage;
   autoPush: boolean;
+  coAuthor?: string | false;
+  maxCompletionTokens?: number;
 }
 
 interface StoredConfig {
@@ -24,15 +28,19 @@ interface StoredConfig {
   model?: string;
   fallbackModel?: string;
   reasoningEffort?: ReasoningEffort | string;
-  mode?: 'custom' | 'openai';
+  mode?: AIMode;
   language?: SupportedLanguage | string;
   autoPush?: boolean;
+  coAuthor?: string | false;
+  maxCompletionTokens?: number;
 }
 
 const DEFAULT_MODEL = 'zai-org/GLM-4.5-FP8';
-const DEFAULT_MODE: 'custom' | 'openai' = 'custom';
+const DEFAULT_MODE: AIMode = 'custom';
 const DEFAULT_LANGUAGE: SupportedLanguage = 'ko';
 const DEFAULT_AUTO_PUSH = false;
+const DEFAULT_CO_AUTHOR = 'git-ai-commit <git-ai-commit@users.noreply.github.com>';
+const CONFIG_SCHEMA_URL = 'https://raw.githubusercontent.com/onaries/git-ai-commit/main/src/schema/config.schema.json';
 
 export class ConfigService {
   private static getConfigFilePath(): string {
@@ -58,7 +66,8 @@ export class ConfigService {
       }
 
       const parsed = JSON.parse(raw);
-      return typeof parsed === 'object' && parsed !== null ? parsed : {};
+      const { $schema, ...config } = typeof parsed === 'object' && parsed !== null ? parsed : {} as Record<string, unknown>;
+      return config as StoredConfig;
     } catch (error) {
       console.warn('Warning: Failed to read configuration file. Falling back to environment variables.');
       return {};
@@ -83,35 +92,42 @@ export class ConfigService {
     return undefined;
   }
 
-  private static normalizeMode(mode?: string): 'custom' | 'openai' {
+  private static normalizeMode(mode?: string): AIMode {
     if (!mode) {
       return DEFAULT_MODE;
     }
 
     const normalized = mode.toLowerCase();
-    return normalized === 'openai' ? 'openai' : 'custom';
+    if (normalized === 'openai') return 'openai';
+    if (normalized === 'gemini') return 'gemini';
+    return 'custom';
   }
 
-  private static resolveEnvConfig(modeOverride?: 'custom' | 'openai'): EnvironmentConfig {
+  private static resolveEnvConfig(modeOverride?: AIMode): EnvironmentConfig {
     const resolvedMode = this.normalizeMode(modeOverride || process.env.AI_MODE);
-    const isOpenAI = resolvedMode === 'openai';
-
-    const apiKey = isOpenAI
-      ? process.env.OPENAI_API_KEY || process.env.AI_API_KEY
-      : process.env.AI_API_KEY || process.env.OPENAI_API_KEY;
 
-    const baseURL = isOpenAI
-      ? process.env.OPENAI_BASE_URL || process.env.AI_BASE_URL
-      : process.env.AI_BASE_URL || process.env.OPENAI_BASE_URL;
-
-    const model = isOpenAI
-      ? process.env.OPENAI_MODEL || process.env.AI_MODEL || DEFAULT_MODEL
-      : process.env.AI_MODEL || process.env.OPENAI_MODEL || DEFAULT_MODEL;
+    let apiKey: string | undefined;
+    let baseURL: string | undefined;
+    let model: string;
+
+    if (resolvedMode === 'gemini') {
+      apiKey = process.env.GEMINI_API_KEY || process.env.AI_API_KEY;
+      baseURL = undefined;
+      model = process.env.AI_MODEL || 'gemini-2.0-flash';
+    } else if (resolvedMode === 'openai') {
+      apiKey = process.env.OPENAI_API_KEY || process.env.AI_API_KEY;
+      baseURL = process.env.OPENAI_BASE_URL || process.env.AI_BASE_URL;
+      model = process.env.OPENAI_MODEL || process.env.AI_MODEL || DEFAULT_MODEL;
+    } else {
+      apiKey = process.env.AI_API_KEY || process.env.OPENAI_API_KEY;
+      baseURL = process.env.AI_BASE_URL || process.env.OPENAI_BASE_URL;
+      model = process.env.AI_MODEL || process.env.OPENAI_MODEL || DEFAULT_MODEL;
+    }
 
     return {
       apiKey: apiKey || undefined,
       baseURL: baseURL || undefined,
-      model: model || DEFAULT_MODEL,
+      model,
       mode: resolvedMode,
       language: DEFAULT_LANGUAGE,
       autoPush: DEFAULT_AUTO_PUSH
@@ -130,7 +146,10 @@ export class ConfigService {
     const reasoningEffort = this.normalizeReasoningEffort(fileConfig.reasoningEffort);
     const language = this.normalizeLanguage(fileConfig.language ?? envConfig.language);
     const autoPush = typeof fileConfig.autoPush === 'boolean' ? fileConfig.autoPush : envConfig.autoPush;
-
+    const coAuthor = fileConfig.coAuthor === false ? false : (fileConfig.coAuthor || DEFAULT_CO_AUTHOR);
+    const maxCompletionTokens = typeof fileConfig.maxCompletionTokens === 'number' && fileConfig.maxCompletionTokens > 0
+      ? fileConfig.maxCompletionTokens
+      : undefined;
     return {
       apiKey,
       baseURL,
@@ -139,7 +158,9 @@ export class ConfigService {
       reasoningEffort,
       mode,
       language,
-      autoPush
+      autoPush,
+      coAuthor,
+      maxCompletionTokens,
     };
   }
 
@@ -176,6 +197,8 @@ export class ConfigService {
       delete next.mode;
     }
 
+    // coAuthor: false means explicitly disabled — persist it so getConfig() sees it
+
     const sanitized = Object.entries(next).reduce<StoredConfig>((acc, [key, value]) => {
       if (value !== undefined) {
         acc[key as keyof StoredConfig] = value as any;
@@ -186,7 +209,7 @@ export class ConfigService {
     }, {});
 
     await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
-    await fsPromises.writeFile(filePath, JSON.stringify(sanitized, null, 2), 'utf-8');
+    await fsPromises.writeFile(filePath, JSON.stringify({ $schema: CONFIG_SCHEMA_URL, ...sanitized }, null, 2), 'utf-8');
   }
 
   static validateConfig(config: { apiKey?: string; language?: string }): void {