kodu 1.2.0 → 2.0.1

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

@@ -6,13 +6,20 @@ import { ConfigService } from '../../core/config/config.service';
 import { PromptService } from '../../core/config/prompt.service';
 import { FsService } from '../../core/file-system/fs.service';
 import { UiService } from '../../core/ui/ui.service';
+import { CleanerService } from '../../shared/cleaner/cleaner.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;
+  clean?: boolean;
 };
 
 type TemplateContext = {
@@ -33,6 +40,7 @@ export class PackCommand extends CommandRunner {
     private readonly promptService: PromptService,
     private readonly fsService: FsService,
     private readonly tokenizer: TokenizerService,
+    private readonly cleaner: CleanerService,
   ) {
     super();
   }
@@ -66,6 +74,42 @@ 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: '--clean',
+    description: 'Strip comments in-memory before packing (files not modified)',
+  })
+  parseClean(): 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 +117,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 +132,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, options.clean);
       const fileList = files.join('\n');
       const { tokens, usdEstimate } = this.tokenizer.count(context);
 
@@ -117,6 +171,9 @@ 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}${options.clean ? ' (comments stripped)' : ''}`,
+      );
       this.ui.log.success(`Saved to ${outputPath}`);
 
       if (options.copy) {
@@ -130,14 +187,27 @@ export class PackCommand extends CommandRunner {
     }
   }
 
-  private async buildContext(files: string[]): Promise<string> {
+  private async buildContext(
+    files: string[],
+    format: OutputFormat,
+    clean = false,
+  ): Promise<string> {
     const chunks = await Promise.all(
       files.map(async (file) => {
-        const content = await this.fsService.readFileRelative(file);
+        let content = await this.fsService.readFileRelative(file);
+        if (clean) {
+          content = this.cleaner.cleanContent(file, content);
+        }
+        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');
   }
 

package/src/commands/pack/pack.module.ts

@@ -2,11 +2,12 @@ import { Module } from '@nestjs/common';
 import { ConfigModule } from '../../core/config/config.module';
 import { FsModule } from '../../core/file-system/fs.module';
 import { UiModule } from '../../core/ui/ui.module';
+import { CleanerService } from '../../shared/cleaner/cleaner.service';
 import { TokenizerModule } from '../../shared/tokenizer/tokenizer.module';
 import { PackCommand } from './pack.command';
 
 @Module({
   imports: [ConfigModule, UiModule, FsModule, TokenizerModule],
-  providers: [PackCommand],
+  providers: [PackCommand, CleanerService],
 })
 export class PackModule {}

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

@@ -1,43 +1,4 @@
 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-_.]+$/, {
-  message:
-    "Model must be in format 'provider/model-name' (e.g., 'openai/gpt-4o')",
-});
-
-const llmCommandSettingsSchema = z
-  .object({
-    maxOutputTokens: z.number().int().positive().optional(),
-  })
-  .passthrough();
-
-const llmCommandSchema = z.object({
-  modelSettings: llmCommandSettingsSchema.optional(),
-});
-
-const createDefaultCommandSettings = () => ({
-  commit: { modelSettings: { maxOutputTokens: DEFAULT_COMMIT_TOKENS } },
-  review: { modelSettings: { maxOutputTokens: DEFAULT_REVIEW_TOKENS } },
-});
-
-const llmCommandsSchema = z
-  .object({
-    commit: llmCommandSchema.optional(),
-    review: llmCommandSchema.optional(),
-  })
-  .default(() => createDefaultCommandSettings());
-
-const llmSchema = z.object({
-  model: modelIdSchema.default(`openai/${DEFAULT_LLM_MODEL}`),
-  apiKeyEnv: z.string().default('OPENAI_API_KEY'),
-  commands: llmCommandsSchema.optional(),
-});
 
 const cleanerSchema = z.object({
   whitelist: z.array(z.string()).default(['//!']),
@@ -63,40 +24,14 @@ const packerSchema = z.object({
   contentBasedBinaryDetection: z.boolean().default(false),
 });
 
-const promptSourceSchema = z.string();
-
 const promptsSchema = z
   .object({
-    review: z.record(z.string(), promptSourceSchema).optional(),
-    commit: promptSourceSchema.optional(),
-    pack: promptSourceSchema.optional(),
+    pack: z.string().optional(),
   })
   .optional();
 
-const serverPathsSchema = z
-  .object({
-    apps: z.string().default('/var/agent-apps'),
-    caddy: z.string().optional(),
-  })
-  .optional();
-
-const serverConfigSchema = z.object({
-  host: z.string(),
-  port: z.number().default(22),
-  user: z.string(),
-  sshKeyPath: z.string(),
-  description: z.string().optional(),
-  paths: serverPathsSchema,
-  env: z.record(z.string(), z.string()).optional(),
-});
-
-const opsSchema = z.object({
-  servers: z.record(z.string(), serverConfigSchema),
-});
-
 export const configSchema = z.object({
   $schema: z.string().optional(),
-  llm: llmSchema.optional(),
   cleaner: cleanerSchema.default({
     whitelist: ['//!'],
     keepJSDoc: true,
@@ -118,8 +53,6 @@ export const configSchema = z.object({
     contentBasedBinaryDetection: false,
   }),
   prompts: promptsSchema,
-  ops: opsSchema.optional(),
 });
 
 export type KoduConfig = z.infer<typeof configSchema>;
-export type ServerConfig = z.infer<typeof serverConfigSchema>;

package/src/core/config/config.service.ts

@@ -21,14 +21,14 @@ export class ConfigService {
 
     if (!result || result.isEmpty || !result.config) {
       this.terminate(
-        'kodu.json config not found. Run `kodu init` to create the file.',
+        'kodu.json not found. Create it in the project root to configure kodu.',
       );
     }
 
     const parsed = configSchema.safeParse(result.config);
 
     if (!parsed.success) {
-      console.error(pc.red('kodu.json config is invalid:'));
+      console.error(pc.red('kodu.json is invalid:'));
       parsed.error.issues.forEach((issue) => {
         const path = issue.path.join('.') || '(root)';
         console.error(pc.red(`- ${path}: ${issue.message}`));

package/src/core/config/prompt.service.ts

@@ -1,19 +1,13 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { Injectable } from '@nestjs/common';
-import { replacePromptVariables } from './default-prompts';
-
-type Variables = Record<string, string | number>;
 
 @Injectable()
 export class PromptService {
   private readonly cache = new Map<string, string>();
 
-  async load(source: string, variables?: Variables): Promise<string> {
-    const raw = await this.readSource(source);
-    return variables
-      ? replacePromptVariables(raw, this.normalize(variables))
-      : raw;
+  async load(source: string): Promise<string> {
+    return this.readSource(source);
   }
 
   async loadFromPromptsDir(name: string): Promise<string> {
@@ -66,29 +60,13 @@ export class PromptService {
     }
     const hasPathSegments = value.includes('/') || value.includes('\\');
     const hasExtension = path.extname(value) !== '';
-
     return value.trim().length > 0 && !hasPathSegments && !hasExtension;
   }
 
   private buildCandidates(name: string): string[] {
     const names = path.extname(name) ? [name] : [`${name}.md`, `${name}.txt`];
-
-    const roots = [path.join(process.cwd(), '.kodu', 'prompts')];
-
-    const candidates: string[] = [];
-    for (const root of roots) {
-      for (const variant of names) {
-        candidates.push(path.join(root, variant));
-      }
-    }
-
-    return candidates;
-  }
-
-  private normalize(variables: Variables): Record<string, string> {
-    return Object.fromEntries(
-      Object.entries(variables).map(([key, value]) => [key, value.toString()]),
-    );
+    const root = path.join(process.cwd(), '.kodu', 'prompts');
+    return names.map((variant) => path.join(root, variant));
   }
 
   private async exists(target: string): Promise<boolean> {