kodu 1.2.0 → 2.0.0

package/kodu.schema.json

@@ -5,74 +5,6 @@
     "$schema": {
       "type": "string"
     },
-    "llm": {
-      "type": "object",
-      "properties": {
-        "model": {
-          "default": "openai/gpt-4o",
-          "type": "string",
-          "pattern": "^[a-zA-Z0-9-_]+\\/[a-zA-Z0-9-_.]+$"
-        },
-        "apiKeyEnv": {
-          "default": "OPENAI_API_KEY",
-          "type": "string"
-        },
-        "commands": {
-          "default": {
-            "commit": {
-              "modelSettings": {
-                "maxOutputTokens": 1500
-              }
-            },
-            "review": {
-              "modelSettings": {
-                "maxOutputTokens": 5000
-              }
-            }
-          },
-          "type": "object",
-          "properties": {
-            "commit": {
-              "type": "object",
-              "properties": {
-                "modelSettings": {
-                  "type": "object",
-                  "properties": {
-                    "maxOutputTokens": {
-                      "type": "integer",
-                      "exclusiveMinimum": 0,
-                      "maximum": 9007199254740991
-                    }
-                  },
-                  "additionalProperties": {}
-                }
-              },
-              "additionalProperties": false
-            },
-            "review": {
-              "type": "object",
-              "properties": {
-                "modelSettings": {
-                  "type": "object",
-                  "properties": {
-                    "maxOutputTokens": {
-                      "type": "integer",
-                      "exclusiveMinimum": 0,
-                      "maximum": 9007199254740991
-                    }
-                  },
-                  "additionalProperties": {}
-                }
-              },
-              "additionalProperties": false
-            }
-          },
-          "additionalProperties": false
-        }
-      },
-      "required": ["model", "apiKeyEnv"],
-      "additionalProperties": false
-    },
     "cleaner": {
       "default": {
         "whitelist": ["//!"],
@@ -156,82 +88,11 @@
     "prompts": {
       "type": "object",
       "properties": {
-        "review": {
-          "type": "object",
-          "propertyNames": {
-            "type": "string"
-          },
-          "additionalProperties": {
-            "type": "string"
-          }
-        },
-        "commit": {
-          "type": "string"
-        },
         "pack": {
           "type": "string"
         }
       },
       "additionalProperties": false
-    },
-    "ops": {
-      "type": "object",
-      "properties": {
-        "servers": {
-          "type": "object",
-          "propertyNames": {
-            "type": "string"
-          },
-          "additionalProperties": {
-            "type": "object",
-            "properties": {
-              "host": {
-                "type": "string"
-              },
-              "port": {
-                "default": 22,
-                "type": "number"
-              },
-              "user": {
-                "type": "string"
-              },
-              "sshKeyPath": {
-                "type": "string"
-              },
-              "description": {
-                "type": "string"
-              },
-              "paths": {
-                "type": "object",
-                "properties": {
-                  "apps": {
-                    "default": "/var/agent-apps",
-                    "type": "string"
-                  },
-                  "caddy": {
-                    "type": "string"
-                  }
-                },
-                "required": ["apps"],
-                "additionalProperties": false
-              },
-              "env": {
-                "type": "object",
-                "propertyNames": {
-                  "type": "string"
-                },
-                "additionalProperties": {
-                  "type": "string"
-                }
-              }
-            },
-            "required": ["host", "port", "user", "sshKeyPath"],
-            "additionalProperties": false
-          }
-        }
-      },
-      "required": ["servers"],
-      "additionalProperties": false
     }
   },
   "required": ["cleaner", "packer"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodu",
-  "version": "1.2.0",
+  "version": "2.0.0",
   "description": "High-performance CLI to prepare codebase for LLMs, automate reviews, and draft commits.",
   "repository": {
     "type": "git",
@@ -50,7 +50,6 @@
     "@inquirer/confirm": "^6.0.4",
     "@inquirer/input": "^5.0.4",
     "@inquirer/select": "^5.0.4",
-    "@mastra/core": "^1.0.4",
     "@nestjs/common": "^11.0.1",
     "@nestjs/core": "^11.0.1",
     "clipboardy": "^5.0.2",

package/src/app.module.ts

@@ -1,14 +1,10 @@
 import { Module } from '@nestjs/common';
 import { CleanModule } from './commands/clean/clean.module';
-import { CommitModule } from './commands/commit/commit.module';
 import { InitModule } from './commands/init/init.module';
-import { OpsModule } from './commands/ops/ops.module';
 import { PackModule } from './commands/pack/pack.module';
-import { ReviewModule } from './commands/review/review.module';
 import { ConfigModule } from './core/config/config.module';
 import { FsModule } from './core/file-system/fs.module';
 import { UiModule } from './core/ui/ui.module';
-import { AiModule } from './shared/ai/ai.module';
 import { GitModule } from './shared/git/git.module';
 import { TokenizerModule } from './shared/tokenizer/tokenizer.module';
 
@@ -18,14 +14,10 @@ import { TokenizerModule } from './shared/tokenizer/tokenizer.module';
     UiModule,
     FsModule,
     GitModule,
-    AiModule,
     TokenizerModule,
     InitModule,
     PackModule,
     CleanModule,
-    ReviewModule,
-    CommitModule,
-    OpsModule,
   ],
 })
 export class AppModule {}

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

@@ -1,342 +1,47 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { Command, CommandRunner } from 'nest-commander';
-import { type KoduConfig } from '../../core/config/config.schema';
-import {
-  DEFAULT_COMMIT_PROMPT,
-  DEFAULT_PACK_PROMPT,
-  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: DEFAULT_COMMIT_TOKENS } },
-  review: { modelSettings: { maxOutputTokens: DEFAULT_REVIEW_TOKENS } },
-});
+const GITIGNORE_ENTRY = '.kodu/context.txt';
 
-@Command({ name: 'init', description: 'Initialize Kodu configuration' })
+@Command({ name: 'init', description: 'Add kodu output to .gitignore' })
 export class InitCommand extends CommandRunner {
   constructor(private readonly ui: UiService) {
     super();
   }
 
   async run(): Promise<void> {
-    const configPath = path.join(process.cwd(), 'kodu.json');
-
-    const defaultLlmConfig = {
-      model: `openai/${DEFAULT_LLM_MODEL}`,
-      apiKeyEnv: 'OPENAI_API_KEY',
-    };
-
-    const defaultConfig: KoduConfig = {
-      $schema:
-        'https://raw.githubusercontent.com/uxname/kodu/refs/heads/master/kodu.schema.json',
-      llm: defaultLlmConfig,
-      ops: {
-        servers: {
-          dev: {
-            host: 'example.com',
-            port: 22,
-            user: 'ubuntu',
-            sshKeyPath: '~/.ssh/id_rsa',
-            description: 'Example AgentOps server',
-            paths: {
-              apps: '/var/agent-apps',
-              caddy: '/var/agent-apps/caddy',
-            },
-          },
-        },
-      },
-      cleaner: {
-        whitelist: ['//!'],
-        keepJSDoc: true,
-        useGitignore: true,
-        ignore: [],
-      },
-      packer: {
-        ignore: [
-          'package-lock.json',
-          'yarn.lock',
-          'pnpm-lock.yaml',
-          '.git',
-          '.kodu',
-          'node_modules',
-          'dist',
-          'coverage',
-        ],
-        useGitignore: true,
-        contentBasedBinaryDetection: false,
-      },
-    };
-
-    const useAi = await this.ui.promptConfirm({
-      message: 'Will you use AI functions?',
-      default: true,
-    });
-
-    let llmConfig: KoduConfig['llm'] | undefined;
-    if (useAi) {
-      const useCustomModel = await this.ui.promptConfirm({
-        message: 'Use your own model?',
-        default: false,
-      });
-
-      let model: string;
-      if (useCustomModel) {
-        model = await this.ui.promptInput({
-          message:
-            'Enter model in format provider/model-name (e.g., openai/gpt-4o):',
-          default: defaultLlmConfig.model,
-          validate: (input) => {
-            if (!input.includes('/')) {
-              return 'Model must be in format provider/model-name';
-            }
-            return true;
-          },
-        });
-      } else {
-        model = await this.ui.promptSelect<string>(
-          this.buildModelQuestion(defaultLlmConfig.model),
-        );
-      }
-
-      llmConfig = {
-        model,
-        apiKeyEnv: defaultLlmConfig.apiKeyEnv,
-        commands: buildDefaultCommandSettings(),
-      };
-    }
-
-    const extendIgnore = await this.ui.promptConfirm({
-      message: 'Modify standard ignore list?',
-      default: false,
-    });
-
-    const ignoreList = extendIgnore
-      ? await this.askIgnoreList(defaultConfig.packer.ignore)
-      : defaultConfig.packer.ignore;
-
-    const additionalWhitelist = await this.ui.promptInput({
-      message:
-        'Additional whitelist prefixes (comma-separated, empty - keep default):',
-      default: '',
-    });
-
-    const whitelist = this.mergeWhitelist(
-      defaultConfig.cleaner.whitelist,
-      additionalWhitelist,
-    );
-
-    const promptPaths = this.buildPromptPaths();
-
-    const configToSave: KoduConfig = {
-      $schema: defaultConfig.$schema,
-      ...(llmConfig && { llm: llmConfig }),
-      cleaner: {
-        whitelist,
-        keepJSDoc: defaultConfig.cleaner.keepJSDoc,
-        useGitignore: defaultConfig.cleaner.useGitignore,
-        ignore: defaultConfig.cleaner.ignore,
-      },
-      packer: {
-        ignore: ignoreList,
-        useGitignore: defaultConfig.packer.useGitignore,
-        contentBasedBinaryDetection:
-          defaultConfig.packer.contentBasedBinaryDetection,
-      },
-      ops: defaultConfig.ops,
-      prompts: {
-        review: {
-          bug: promptPaths.review.bug,
-          style: promptPaths.review.style,
-          security: promptPaths.review.security,
-        },
-        commit: promptPaths.commit,
-        pack: promptPaths.pack,
-      },
-    };
-
-    await this.writeConfig(configPath, configToSave);
-    await this.ensurePromptFiles(promptPaths);
-    await this.ensureGitignore();
-
-    this.ui.log.success('Kodu configuration created.');
-    if (useAi) {
-      this.ui.log.info('🎉 Kodu initialized! Run `kodu pack` to continue.');
-    } else {
-      this.ui.log.info('🎉 Kodu initialized! Available commands: pack, clean.');
-      this.ui.log.info(
-        'To use AI functions (review, commit) add llm section to kodu.json.',
-      );
-    }
-  }
-
-  private buildModelQuestion(defaultModel: string) {
-    return {
-      message: 'Select AI model',
-      choices: [
-        {
-          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' },
-        {
-          name: 'Anthropic Claude 3.5 Sonnet',
-          value: 'anthropic/claude-3-5-sonnet-20241022',
-        },
-        { name: 'Google Gemini 2.5 Flash', value: 'google/gemini-2.5-flash' },
-      ],
-      default: defaultModel,
-    };
-  }
-
-  private async askIgnoreList(defaultIgnore: string[]): Promise<string[]> {
-    const answer = await this.ui.promptInput({
-      message: 'Specify ignore patterns (comma-separated)',
-      default: defaultIgnore.join(', '),
-    });
-
-    return answer
-      .split(',')
-      .map((item) => item.trim())
-      .filter((item) => item.length > 0);
-  }
-
-  private mergeWhitelist(defaultWhitelist: string[], extra: string): string[] {
-    if (!extra.trim()) {
-      return defaultWhitelist;
-    }
-
-    const additions = extra
-      .split(',')
-      .map((item) => item.trim())
-      .filter((item) => item.length > 0);
-
-    return Array.from(new Set([...defaultWhitelist, ...additions]));
-  }
-
-  private async writeConfig(
-    configPath: string,
-    config: KoduConfig,
-  ): Promise<void> {
-    if (await this.fileExists(configPath)) {
-      const overwrite = await this.ui.promptConfirm({
-        message: 'kodu.json already exists. Overwrite?',
-        default: false,
-      });
-
-      if (!overwrite) {
-        this.ui.log.warn(
-          'Initialization cancelled: kodu.json file already exists.',
-        );
-        return;
-      }
-    }
-
-    await fs.writeFile(
-      configPath,
-      `${JSON.stringify(config, null, 2)}\n`,
-      'utf8',
-    );
-    this.ui.log.success(`Saved ${configPath}`);
+    await this.updateGitignore();
+    this.ui.log.success('Done.');
   }
 
-  private async ensurePromptFiles(
-    paths: ReturnType<InitCommand['buildPromptPaths']>,
-  ): Promise<void> {
-    const promptDir = path.join(process.cwd(), '.kodu', 'prompts');
-    await fs.mkdir(promptDir, { recursive: true });
-
-    const keepFile = path.join(promptDir, '.keep');
-    if (!(await this.fileExists(keepFile))) {
-      await fs.writeFile(keepFile, '');
-    }
-
-    await Promise.all([
-      this.writePromptIfMissing(paths.review.bug, DEFAULT_REVIEW_PROMPTS.bug),
-      this.writePromptIfMissing(
-        paths.review.style,
-        DEFAULT_REVIEW_PROMPTS.style,
-      ),
-      this.writePromptIfMissing(
-        paths.review.security,
-        DEFAULT_REVIEW_PROMPTS.security,
-      ),
-      this.writePromptIfMissing(paths.commit, DEFAULT_COMMIT_PROMPT),
-      this.writePromptIfMissing(paths.pack, DEFAULT_PACK_PROMPT),
-    ]);
-  }
-
-  private buildPromptPaths() {
-    return {
-      review: {
-        bug: path.posix.join('.kodu', 'prompts', 'review-bug.md'),
-        style: path.posix.join('.kodu', 'prompts', 'review-style.md'),
-        security: path.posix.join('.kodu', 'prompts', 'review-security.md'),
-      },
-      commit: path.posix.join('.kodu', 'prompts', 'commit.md'),
-      pack: path.posix.join('.kodu', 'prompts', 'pack.md'),
-    } as const;
-  }
-
-  private async writePromptIfMissing(
-    target: string,
-    content: string,
-  ): Promise<void> {
-    const absolute = path.isAbsolute(target)
-      ? target
-      : path.join(process.cwd(), target);
+  private async updateGitignore(): Promise<void> {
+    const gitignorePath = path.join(process.cwd(), '.gitignore');
 
-    if (await this.fileExists(absolute)) {
+    if (!(await this.exists(gitignorePath))) {
+      this.ui.log.warn('.gitignore not found, skipping.');
       return;
     }
 
-    await fs.mkdir(path.dirname(absolute), { recursive: true });
-    await fs.writeFile(absolute, `${content}\n`, 'utf8');
-  }
-
-  private async ensureGitignore(): Promise<void> {
-    const gitignorePath = path.join(process.cwd(), '.gitignore');
-    const content = (await this.fileExists(gitignorePath))
-      ? await fs.readFile(gitignorePath, 'utf8')
-      : '';
-
+    const content = await fs.readFile(gitignorePath, 'utf8');
     const lines = content.split(/\r?\n/);
-    const additions: string[] = [];
-
-    if (!lines.some((line) => line.trim() === '.env')) {
-      const addEnv = await this.ui.promptConfirm({
-        message: '.env not in .gitignore. Add it?',
-        default: true,
-      });
-
-      if (addEnv) {
-        additions.push('.env');
-      }
-    }
 
-    if (additions.length === 0) {
+    if (lines.some((line) => line.trim() === GITIGNORE_ENTRY)) {
+      this.ui.log.info(`${GITIGNORE_ENTRY} already in .gitignore`);
       return;
     }
 
     const trimmed = content.trimEnd();
     const next =
-      trimmed.length > 0
-        ? `${trimmed}\n${additions.join('\n')}`
-        : additions.join('\n');
+      trimmed.length > 0 ? `${trimmed}\n${GITIGNORE_ENTRY}` : GITIGNORE_ENTRY;
     await fs.writeFile(gitignorePath, `${next}\n`, 'utf8');
-    this.ui.log.success('Updated .gitignore');
+    this.ui.log.success(`Added ${GITIGNORE_ENTRY} to .gitignore`);
   }
 
-  private async fileExists(targetPath: string): Promise<boolean> {
+  private async exists(target: string): Promise<boolean> {
     try {
-      await fs.access(targetPath);
+      await fs.access(target);
       return true;
     } catch {
       return false;

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

@@ -8,11 +8,16 @@ import { FsService } from '../../core/file-system/fs.service';
 import { UiService } from '../../core/ui/ui.service';
 import { TokenizerService } from '../../shared/tokenizer/tokenizer.service';
 
+type OutputFormat = 'xml' | 'text';
+
 type PackOptions = {
   copy?: boolean;
   template?: string;
   out?: string;
   path?: string[];
+  exclude?: string[];
+  list?: boolean;
+  format?: OutputFormat;
 };
 
 type TemplateContext = {
@@ -66,6 +71,34 @@ export class PackCommand extends CommandRunner {
     return [...previous, value];
   }
 
+  @Option({
+    flags: '-e, --exclude <pattern>',
+    description: 'Additional exclude pattern (repeatable)',
+  })
+  parseExclude(value: string, previous: string[] = []): string[] {
+    return [...previous, value];
+  }
+
+  @Option({
+    flags: '-l, --list',
+    description: 'Print file list only, without content',
+  })
+  parseList(): boolean {
+    return true;
+  }
+
+  @Option({
+    flags: '-f, --format <format>',
+    description: 'Output format: xml (default) or text',
+  })
+  parseFormat(value: string): OutputFormat {
+    if (value !== 'xml' && value !== 'text') {
+      this.ui.log.warn(`Unknown format "${value}", using "xml"`);
+      return 'xml';
+    }
+    return value;
+  }
+
   async run(_inputs: string[], options: PackOptions): Promise<void> {
     const spinner = this.ui
       .createSpinner({ text: 'Collecting files...' })
@@ -73,10 +106,11 @@ export class PackCommand extends CommandRunner {
 
     try {
       const { packer } = this.configService.getConfig();
+      const extraExcludes = options.exclude ?? [];
       const files = await this.fsService.findProjectFiles({
         excludeBinary: true,
         useGitignore: packer.useGitignore,
-        ignore: packer.ignore,
+        ignore: [...packer.ignore, ...extraExcludes],
         contentBasedBinaryDetection: packer.contentBasedBinaryDetection,
         rootPaths: options.path,
       });
@@ -87,7 +121,16 @@ export class PackCommand extends CommandRunner {
         return;
       }
 
-      const context = await this.buildContext(files);
+      if (options.list) {
+        spinner.success(`Found ${files.length} files`);
+        for (const file of files) {
+          this.ui.log.info(file);
+        }
+        return;
+      }
+
+      const format: OutputFormat = options.format ?? 'xml';
+      const context = await this.buildContext(files, format);
       const fileList = files.join('\n');
       const { tokens, usdEstimate } = this.tokenizer.count(context);
 
@@ -117,6 +160,7 @@ export class PackCommand extends CommandRunner {
       this.ui.log.info(`Files: ${files.length}`);
       this.ui.log.info(`Tokens: ${tokens}`);
       this.ui.log.info(`Cost estimate: ~$${usdEstimate.toFixed(4)}`);
+      this.ui.log.info(`Format: ${format}`);
       this.ui.log.success(`Saved to ${outputPath}`);
 
       if (options.copy) {
@@ -130,14 +174,23 @@ export class PackCommand extends CommandRunner {
     }
   }
 
-  private async buildContext(files: string[]): Promise<string> {
+  private async buildContext(
+    files: string[],
+    format: OutputFormat,
+  ): Promise<string> {
     const chunks = await Promise.all(
       files.map(async (file) => {
         const content = await this.fsService.readFileRelative(file);
+        if (format === 'xml') {
+          return `<file path="${file}">\n${content}\n</file>`;
+        }
         return `// file: ${file}\n${content}`;
       }),
     );
 
+    if (format === 'xml') {
+      return `<files>\n${chunks.join('\n\n')}\n</files>`;
+    }
     return chunks.join('\n\n');
   }