kodu 1.1.12 → 1.1.13

package/kodu.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/uxname/kodu/refs/heads/master/kodu.schema.json",
   "llm": {
-    "model": "openai/gpt-5-mini",
+    "model": "openai/gpt-4o",
     "apiKeyEnv": "OPENAI_API_KEY",
     "commands": {
       "commit": {
@@ -19,7 +19,8 @@
   "cleaner": {
     "whitelist": ["//!"],
     "keepJSDoc": true,
-    "useGitignore": true
+    "useGitignore": true,
+    "ignore": []
   },
   "packer": {
     "ignore": [
@@ -32,7 +33,8 @@
       "dist",
       "coverage"
     ],
-    "useGitignore": true
+    "useGitignore": true,
+    "contentBasedBinaryDetection": false
   },
   "prompts": {
     "review": {

package/kodu.schema.json

@@ -9,7 +9,7 @@
       "type": "object",
       "properties": {
         "model": {
-          "default": "openai/gpt-5-mini",
+          "default": "openai/gpt-4o",
           "type": "string",
           "pattern": "^[a-zA-Z0-9-_]+\\/[a-zA-Z0-9-_.]+$"
         },
@@ -77,7 +77,8 @@
       "default": {
         "whitelist": ["//!"],
         "keepJSDoc": true,
-        "useGitignore": true
+        "useGitignore": true,
+        "ignore": []
       },
       "type": "object",
       "properties": {
@@ -95,9 +96,16 @@
         "useGitignore": {
           "default": true,
           "type": "boolean"
+        },
+        "ignore": {
+          "default": [],
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
         }
       },
-      "required": ["whitelist", "keepJSDoc", "useGitignore"],
+      "required": ["whitelist", "keepJSDoc", "useGitignore", "ignore"],
       "additionalProperties": false
     },
     "packer": {
@@ -112,7 +120,8 @@
           "dist",
           "coverage"
         ],
-        "useGitignore": true
+        "useGitignore": true,
+        "contentBasedBinaryDetection": false
       },
       "type": "object",
       "properties": {
@@ -135,9 +144,13 @@
         "useGitignore": {
           "default": true,
           "type": "boolean"
+        },
+        "contentBasedBinaryDetection": {
+          "default": false,
+          "type": "boolean"
         }
       },
-      "required": ["ignore", "useGitignore"],
+      "required": ["ignore", "useGitignore", "contentBasedBinaryDetection"],
       "additionalProperties": false
     },
     "prompts": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodu",
-  "version": "1.1.12",
+  "version": "1.1.13",
   "description": "High-performance CLI to prepare codebase for LLMs, automate reviews, and draft commits.",
   "repository": {
     "type": "git",
@@ -55,6 +55,7 @@
     "@nestjs/core": "^11.0.1",
     "clipboardy": "^5.0.2",
     "execa": "^9.6.1",
+    "ignore": "^7.0.5",
     "js-tiktoken": "^1.0.21",
     "lilconfig": "^3.1.3",
     "nest-commander": "^3.20.1",

package/src/commands/clean/clean.command.ts

@@ -44,9 +44,14 @@ export class CleanCommand extends CommandRunner {
       .start();
 
     try {
-      const { cleaner: cleanerConfig } = this.config.getConfig();
+      const { cleaner: cleanerConfig, packer } = this.config.getConfig();
+      const ignorePatterns = [
+        ...(packer.ignore ?? []),
+        ...(cleanerConfig.ignore ?? []),
+      ];
       const allFiles = await this.fsService.findProjectFiles({
         useGitignore: cleanerConfig.useGitignore,
+        ignore: ignorePatterns,
       });
       const targets = await this.collectTargets(allFiles, options);
 

package/src/commands/init/init.command.ts

@@ -8,10 +8,15 @@ import {
   DEFAULT_REVIEW_PROMPTS,
 } from '../../core/config/default-prompts';
 import { UiService } from '../../core/ui/ui.service';
+import {
+  DEFAULT_COMMIT_TOKENS,
+  DEFAULT_LLM_MODEL,
+  DEFAULT_REVIEW_TOKENS,
+} from '../../shared/constants';
 
 const buildDefaultCommandSettings = () => ({
-  commit: { modelSettings: { maxOutputTokens: 1500 } },
-  review: { modelSettings: { maxOutputTokens: 5000 } },
+  commit: { modelSettings: { maxOutputTokens: DEFAULT_COMMIT_TOKENS } },
+  review: { modelSettings: { maxOutputTokens: DEFAULT_REVIEW_TOKENS } },
 });
 
 @Command({ name: 'init', description: 'Initialize Kodu configuration' })
@@ -24,7 +29,7 @@ export class InitCommand extends CommandRunner {
     const configPath = path.join(process.cwd(), 'kodu.json');
 
     const defaultLlmConfig = {
-      model: 'openai/gpt-5-mini',
+      model: `openai/${DEFAULT_LLM_MODEL}`,
       apiKeyEnv: 'OPENAI_API_KEY',
     };
 
@@ -32,7 +37,12 @@ export class InitCommand extends CommandRunner {
       $schema:
         'https://raw.githubusercontent.com/uxname/kodu/refs/heads/master/kodu.schema.json',
       llm: defaultLlmConfig,
-      cleaner: { whitelist: ['//!'], keepJSDoc: true, useGitignore: true },
+      cleaner: {
+        whitelist: ['//!'],
+        keepJSDoc: true,
+        useGitignore: true,
+        ignore: [],
+      },
       packer: {
         ignore: [
           'package-lock.json',
@@ -45,6 +55,7 @@ export class InitCommand extends CommandRunner {
           'coverage',
         ],
         useGitignore: true,
+        contentBasedBinaryDetection: false,
       },
     };
 
@@ -64,7 +75,7 @@ export class InitCommand extends CommandRunner {
       if (useCustomModel) {
         model = await this.ui.promptInput({
           message:
-            'Enter model in format provider/model-name (e.g., openai/gpt-5-mini):',
+            'Enter model in format provider/model-name (e.g., openai/gpt-4o):',
           default: defaultLlmConfig.model,
           validate: (input) => {
             if (!input.includes('/')) {
@@ -115,10 +126,13 @@ export class InitCommand extends CommandRunner {
         whitelist,
         keepJSDoc: defaultConfig.cleaner.keepJSDoc,
         useGitignore: defaultConfig.cleaner.useGitignore,
+        ignore: defaultConfig.cleaner.ignore,
       },
       packer: {
         ignore: ignoreList,
         useGitignore: defaultConfig.packer.useGitignore,
+        contentBasedBinaryDetection:
+          defaultConfig.packer.contentBasedBinaryDetection,
       },
       prompts: {
         review: {
@@ -151,8 +165,8 @@ export class InitCommand extends CommandRunner {
       message: 'Select AI model',
       choices: [
         {
-          name: 'OpenAI GPT-5 Mini (recommended)',
-          value: 'openai/gpt-5-mini',
+          name: 'OpenAI GPT-4o (recommended)',
+          value: `openai/${DEFAULT_LLM_MODEL}`,
         },
         { name: 'OpenAI GPT-4o Mini', value: 'openai/gpt-4o-mini' },
         { name: 'OpenAI GPT-4o', value: 'openai/gpt-4o' },

package/src/commands/pack/pack.command.ts

@@ -63,8 +63,12 @@ export class PackCommand extends CommandRunner {
       .start();
 
     try {
+      const { packer } = this.configService.getConfig();
       const files = await this.fsService.findProjectFiles({
         excludeBinary: true,
+        useGitignore: packer.useGitignore,
+        ignore: packer.ignore,
+        contentBasedBinaryDetection: packer.contentBasedBinaryDetection,
       });
 
       if (files.length === 0) {
@@ -120,7 +124,8 @@ export class PackCommand extends CommandRunner {
     const chunks = await Promise.all(
       files.map(async (file) => {
         const content = await this.fsService.readFileRelative(file);
-        return `// file: ${file}\n${content}`;
+        const posixPath = file.split(path.sep).join(path.posix.sep);
+        return `// file: ${posixPath}\n${content}`;
       }),
     );
 

package/src/commands/review/review.command.ts

@@ -3,6 +3,7 @@ import clipboard from 'clipboardy';
 import { Command, CommandRunner, Option } from 'nest-commander';
 import { UiService } from '../../core/ui/ui.service';
 import { AiService, type ReviewMode } from '../../shared/ai/ai.service';
+import { WARNING_TOKEN_THRESHOLD } from '../../shared/constants';
 import { GitService } from '../../shared/git/git.service';
 import { TokenizerService } from '../../shared/tokenizer/tokenizer.service';
 
@@ -143,8 +144,7 @@ export class ReviewCommand extends CommandRunner {
       }
 
       const tokens = this.tokenizer.count(diff);
-      const warningBudget = 12000;
-      if (tokens.tokens > warningBudget) {
+      if (tokens.tokens > WARNING_TOKEN_THRESHOLD) {
         this.ui.log.warn(
           `Large context (${tokens.tokens} tokens, ~$${tokens.usdEstimate.toFixed(2)}). Review may cost more.`,
         );

package/src/core/config/config.schema.ts

@@ -1,4 +1,9 @@
 import { z } from 'zod';
+import {
+  DEFAULT_COMMIT_TOKENS,
+  DEFAULT_LLM_MODEL,
+  DEFAULT_REVIEW_TOKENS,
+} from '../../shared/constants';
 
 // Model ID format: provider/model-name (e.g., "openai/gpt-4o", "anthropic/claude-4-5-sonnet")
 const modelIdSchema = z.string().regex(/^[a-zA-Z0-9-_]+\/[a-zA-Z0-9-_.]+$/, {
@@ -17,8 +22,8 @@ const llmCommandSchema = z.object({
 });
 
 const createDefaultCommandSettings = () => ({
-  commit: { modelSettings: { maxOutputTokens: 1500 } },
-  review: { modelSettings: { maxOutputTokens: 5000 } },
+  commit: { modelSettings: { maxOutputTokens: DEFAULT_COMMIT_TOKENS } },
+  review: { modelSettings: { maxOutputTokens: DEFAULT_REVIEW_TOKENS } },
 });
 
 const llmCommandsSchema = z
@@ -29,7 +34,7 @@ const llmCommandsSchema = z
   .default(() => createDefaultCommandSettings());
 
 const llmSchema = z.object({
-  model: modelIdSchema.default('openai/gpt-5-mini'),
+  model: modelIdSchema.default(`openai/${DEFAULT_LLM_MODEL}`),
   apiKeyEnv: z.string().default('OPENAI_API_KEY'),
   commands: llmCommandsSchema.optional(),
 });
@@ -38,6 +43,7 @@ const cleanerSchema = z.object({
   whitelist: z.array(z.string()).default(['//!']),
   keepJSDoc: z.boolean().default(true),
   useGitignore: z.boolean().default(true),
+  ignore: z.array(z.string()).default([]),
 });
 
 const packerSchema = z.object({
@@ -54,6 +60,7 @@ const packerSchema = z.object({
       'coverage',
     ]),
   useGitignore: z.boolean().default(true),
+  contentBasedBinaryDetection: z.boolean().default(false),
 });
 
 const promptSourceSchema = z.string();
@@ -73,6 +80,7 @@ export const configSchema = z.object({
     whitelist: ['//!'],
     keepJSDoc: true,
     useGitignore: true,
+    ignore: [],
   }),
   packer: packerSchema.default({
     ignore: [
@@ -86,6 +94,7 @@ export const configSchema = z.object({
       'coverage',
     ],
     useGitignore: true,
+    contentBasedBinaryDetection: false,
   }),
   prompts: promptsSchema,
 });

package/src/core/file-system/fs.service.ts

@@ -1,123 +1,109 @@
+import type { Stats } from 'node:fs';
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { Injectable } from '@nestjs/common';
+import ignore from 'ignore';
 import { glob } from 'tinyglobby';
+import {
+  BINARY_EXTENSIONS,
+  KNOWN_TEXT_EXTENSIONS,
+  MAX_FILE_SIZE_BYTES,
+} from '../../shared/constants';
 import { ConfigService } from '../config/config.service';
-
-const BINARY_EXTENSIONS = new Set([
-  '.png',
-  '.jpg',
-  '.jpeg',
-  '.webp',
-  '.gif',
-  '.bmp',
-  '.ico',
-  '.tif',
-  '.tiff',
-  '.psd',
-  '.ai',
-  '.sketch',
-  '.heic',
-  '.heif',
-  '.mp3',
-  '.wav',
-  '.flac',
-  '.ogg',
-  '.m4a',
-  '.mp4',
-  '.mkv',
-  '.mov',
-  '.avi',
-  '.webm',
-  '.wmv',
-  '.flv',
-  '.mpg',
-  '.mpeg',
-  '.ogv',
-  '.zip',
-  '.gz',
-  '.tgz',
-  '.bz2',
-  '.xz',
-  '.rar',
-  '.7z',
-  '.tar',
-  '.pdf',
-  '.exe',
-  '.dll',
-  '.so',
-  '.dylib',
-  '.class',
-  '.jar',
-  '.war',
-  '.ear',
-  '.ttf',
-  '.otf',
-  '.woff',
-  '.woff2',
-  '.eot',
-  '.bin',
-  '.pak',
-  '.dat',
-]);
+import { UiService } from '../ui/ui.service';
 
 const BINARY_PROBE_SIZE = 8192;
+const GLOB_IGNORE = ['.git/**'];
+
+type FindProjectFilesOptions = {
+  ignore?: string[];
+  useGitignore?: boolean;
+  excludeBinary?: boolean;
+  contentBasedBinaryDetection?: boolean;
+  maxFileSizeBytes?: number;
+};
 
 @Injectable()
 export class FsService {
-  constructor(private readonly configService: ConfigService) {}
+  constructor(
+    private readonly configService: ConfigService,
+    private readonly ui: UiService,
+  ) {}
 
   async findProjectFiles(
-    options: {
-      ignore?: string[];
-      useGitignore?: boolean;
-      excludeBinary?: boolean;
-    } = {},
+    options: FindProjectFilesOptions = {},
   ): Promise<string[]> {
     const { packer } = this.configService.getConfig();
     const shouldUseGitignore = options.useGitignore ?? packer.useGitignore;
-    const gitignore = shouldUseGitignore
+    const gitignorePatterns = shouldUseGitignore
       ? await this.readGitignorePatterns()
       : [];
-    const ignorePatterns = this.normalizeIgnorePatterns([
-      ...(options.ignore ?? packer.ignore),
-      ...gitignore,
-    ]);
+
+    const ig = ignore();
+    const rawIgnorePatterns = options.ignore ?? packer.ignore ?? [];
+    const ignorePatterns = rawIgnorePatterns
+      .map((pattern) => pattern.trim())
+      .filter((pattern) => pattern.length > 0)
+      .map((pattern) => pattern.replace(/\\/g, '/'));
+    if (ignorePatterns.length > 0) {
+      ig.add(ignorePatterns);
+    }
+    if (gitignorePatterns.length > 0) {
+      ig.add(gitignorePatterns);
+    }
 
     const entries = await glob(['**/*'], {
       onlyFiles: true,
       absolute: true,
-      ignore: ignorePatterns,
+      dot: true,
+      ignore: GLOB_IGNORE,
     });
 
-    // Convert to project-relative paths and sort
     const relativePaths = entries
       .map((entry) => path.relative(process.cwd(), entry))
-      .filter((relative) => relative.length > 0)
+      .map((relative) => this.toPosixPath(relative))
+      .filter((relative) => relative.length > 0);
+
+    const filtered = ig
+      .filter(relativePaths)
       .sort((a, b) => a.localeCompare(b));
 
     // By default exclude binary files when collecting project files (so pack will skip them).
     // Consumers can override with options.excludeBinary = false.
     const excludeBinary = options.excludeBinary ?? true;
-    if (!excludeBinary) {
-      return relativePaths;
-    }
+    const useContentDetection =
+      options.contentBasedBinaryDetection ??
+      packer.contentBasedBinaryDetection ??
+      false;
+    const maxFileSize = options.maxFileSizeBytes ?? MAX_FILE_SIZE_BYTES;
 
-    // Heuristic: consider a file binary if it contains a NUL byte in the first chunk.
-    // Read a small chunk of each file (or the whole file if smaller) and test for 0x00.
     const textFiles: string[] = [];
 
-    for (const rel of relativePaths) {
-      if (this.isLikelyBinaryByExtension(rel)) {
+    for (const rel of filtered) {
+      const abs = path.resolve(process.cwd(), rel);
+      let stats: Stats;
+
+      try {
+        stats = await fs.stat(abs);
+      } catch {
         continue;
       }
 
-      const abs = path.resolve(process.cwd(), rel);
-      const containsNullByte = await this.hasNullByte(abs);
+      if (stats.size > maxFileSize) {
+        this.ui.log.warn(
+          `Skipping large file: ${rel} (>${(maxFileSize / (1024 * 1024)).toFixed(0)}MB)`,
+        );
+        continue;
+      }
 
-      if (!containsNullByte) {
-        textFiles.push(rel);
+      if (
+        excludeBinary &&
+        (await this.shouldExcludeBinary(rel, abs, useContentDetection))
+      ) {
+        continue;
       }
+
+      textFiles.push(rel);
     }
 
     return textFiles;
@@ -142,67 +128,43 @@ export class FsService {
     }
   }
 
-  private normalizeIgnorePatterns(patterns: string[]): string[] {
-    const result: string[] = [];
-
-    for (const raw of patterns) {
-      const trimmed = raw.trim();
-
-      if (!trimmed || trimmed.startsWith('#')) {
-        continue;
-      }
-
-      if (trimmed.startsWith('!')) {
-        // tinyglobby ignore list does not support re-includes
-        continue;
-      }
-
-      const expanded = this.expandIgnorePattern(trimmed);
-      result.push(...expanded);
-    }
-
-    return Array.from(new Set(result));
+  private toPosixPath(relativePath: string): string {
+    return relativePath.split(path.sep).join(path.posix.sep);
   }
 
-  private expandIgnorePattern(pattern: string): string[] {
-    const withoutBang = pattern.replace(/^!/, '');
-    const normalized = withoutBang.replace(/^\/+/g, '');
-
-    if (!normalized) {
-      return [];
-    }
-
-    const isDirectory = normalized.endsWith('/');
-    const base = isDirectory ? normalized.slice(0, -1) : normalized;
-    const hasGlob = /[*?[{]/.test(base);
-    const segments = base.split('/');
+  private isBinaryExtension(relativePath: string): boolean {
+    const ext = path.extname(relativePath).toLowerCase();
+    return ext.length > 0 && BINARY_EXTENSIONS.has(ext);
+  }
 
-    if (isDirectory) {
-      return [`${base}/**`, `**/${base}/**`];
+  private isKnownTextFile(relativePath: string): boolean {
+    const ext = path.extname(relativePath).toLowerCase();
+    if (ext && KNOWN_TEXT_EXTENSIONS.has(ext)) {
+      return true;
     }
 
-    if (!hasGlob && segments.length === 1) {
-      if (base.includes('.')) {
-        return [`**/${base}`];
-      }
+    const baseName = path.basename(relativePath).toLowerCase();
+    return KNOWN_TEXT_EXTENSIONS.has(baseName);
+  }
 
-      return [`**/${base}`, `${base}/**`, `**/${base}/**`];
+  private async shouldExcludeBinary(
+    relativePath: string,
+    absolutePath: string,
+    detectByContent: boolean,
+  ): Promise<boolean> {
+    if (this.isKnownTextFile(relativePath)) {
+      return false;
     }
 
-    if (!hasGlob) {
-      return [base, `**/${base}`, `${base}/**`];
+    if (this.isBinaryExtension(relativePath)) {
+      return true;
     }
 
-    if (!base.startsWith('**/')) {
-      return [`**/${base}`];
+    if (!detectByContent) {
+      return false;
     }
 
-    return [base];
-  }
-
-  private isLikelyBinaryByExtension(relativePath: string): boolean {
-    const ext = path.extname(relativePath).toLowerCase();
-    return ext.length > 0 && BINARY_EXTENSIONS.has(ext);
+    return this.hasNullByte(absolutePath);
   }
 
   private async hasNullByte(absolutePath: string): Promise<boolean> {

package/src/shared/ai/ai.service.ts

@@ -8,12 +8,10 @@ import {
   STANDARD_REVIEW_MODES,
 } from '../../core/config/default-prompts';
 import { PromptService } from '../../core/config/prompt.service';
+import { DEFAULT_COMMIT_TOKENS, DEFAULT_REVIEW_TOKENS } from '../constants';
 
 export type ReviewMode = string;
 
-const DEFAULT_COMMIT_MAX_OUTPUT_TOKENS = 1500;
-const DEFAULT_REVIEW_MAX_OUTPUT_TOKENS = 5000;
-
 type ModelSettings = Record<string, unknown> & {
   maxOutputTokens?: number;
 };
@@ -176,9 +174,7 @@ export class AiService {
     const config = this.configService.getConfig();
     const commands = config.llm?.commands;
     const defaultMax =
-      command === 'commit'
-        ? DEFAULT_COMMIT_MAX_OUTPUT_TOKENS
-        : DEFAULT_REVIEW_MAX_OUTPUT_TOKENS;
+      command === 'commit' ? DEFAULT_COMMIT_TOKENS : DEFAULT_REVIEW_TOKENS;
     const base: ModelSettings = { maxOutputTokens: defaultMax };
 
     if (!commands) {