kodu 1.1.2 → 1.1.4

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

@@ -0,0 +1,193 @@
+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 { UiService } from '../../core/ui/ui.service';
+
+@Command({ name: 'init', description: 'Инициализация конфигурации Kodu' })
+export class InitCommand extends CommandRunner {
+  constructor(private readonly ui: UiService) {
+    super();
+  }
+
+  async run(): Promise<void> {
+    const configPath = path.join(process.cwd(), 'kodu.json');
+
+    const defaultConfig: KoduConfig = {
+      llm: { provider: 'openai', model: 'gpt-4o', apiKeyEnv: 'OPENAI_API_KEY' },
+      cleaner: { whitelist: ['//!'], keepJSDoc: true },
+      packer: {
+        ignore: [
+          'package-lock.json',
+          'yarn.lock',
+          'pnpm-lock.yaml',
+          '.git',
+          '.kodu',
+          'node_modules',
+          'dist',
+          'coverage',
+        ],
+      },
+    };
+
+    const provider = await this.ui.promptSelect<'openai'>(
+      this.buildProviderQuestion(defaultConfig.llm.provider),
+    );
+
+    const extendIgnore = await this.ui.promptConfirm({
+      message: 'Изменить стандартный ignore-список?',
+      default: false,
+    });
+
+    const ignoreList = extendIgnore
+      ? await this.askIgnoreList(defaultConfig.packer.ignore)
+      : defaultConfig.packer.ignore;
+
+    const additionalWhitelist = await this.ui.promptInput({
+      message:
+        'Дополнительные префиксы для whitelist (через запятую, пусто — оставить дефолт):',
+      default: '',
+    });
+
+    const whitelist = this.mergeWhitelist(
+      defaultConfig.cleaner.whitelist,
+      additionalWhitelist,
+    );
+
+    const configToSave: KoduConfig = {
+      llm: {
+        provider,
+        model: defaultConfig.llm.model,
+        apiKeyEnv: defaultConfig.llm.apiKeyEnv,
+      },
+      cleaner: { whitelist, keepJSDoc: defaultConfig.cleaner.keepJSDoc },
+      packer: { ignore: ignoreList },
+    };
+
+    await this.writeConfig(configPath, configToSave);
+    await this.ensureKoduFolders();
+    await this.ensureGitignore();
+
+    this.ui.log.success('Конфигурация Kodu создана.');
+    this.ui.log.info(
+      '🎉 Kodu initialized! Запустите `kodu pack`, чтобы продолжить.',
+    );
+  }
+
+  private buildProviderQuestion(defaultProvider: 'openai') {
+    return {
+      message: 'Выберите AI-провайдера',
+      choices: [{ name: 'OpenAI', value: 'openai' as const }],
+      default: defaultProvider,
+    };
+  }
+
+  private async askIgnoreList(defaultIgnore: string[]): Promise<string[]> {
+    const answer = await this.ui.promptInput({
+      message: 'Укажите ignore-паттерны через запятую',
+      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 уже существует. Перезаписать?',
+        default: false,
+      });
+
+      if (!overwrite) {
+        this.ui.log.warn('Инициализация отменена: файл kodu.json уже есть.');
+        return;
+      }
+    }
+
+    await fs.writeFile(
+      configPath,
+      `${JSON.stringify(config, null, 2)}\n`,
+      'utf8',
+    );
+    this.ui.log.success(`Сохранен ${configPath}`);
+  }
+
+  private async ensureKoduFolders(): Promise<void> {
+    const koduDir = path.join(process.cwd(), '.kodu');
+    const promptsDir = path.join(koduDir, 'prompts');
+
+    await fs.mkdir(promptsDir, { recursive: true });
+
+    const keepFile = path.join(promptsDir, '.keep');
+    if (!(await this.fileExists(keepFile))) {
+      await fs.writeFile(keepFile, '');
+    }
+  }
+
+  private async ensureGitignore(): Promise<void> {
+    const gitignorePath = path.join(process.cwd(), '.gitignore');
+    const content = (await this.fileExists(gitignorePath))
+      ? await fs.readFile(gitignorePath, 'utf8')
+      : '';
+
+    const lines = content.split(/\r?\n/);
+    const additions: string[] = [];
+
+    if (
+      !lines.some((line) => line.trim() === '.kodu' || line.trim() === '.kodu/')
+    ) {
+      additions.push('.kodu/');
+    }
+
+    if (!lines.some((line) => line.trim() === '.env')) {
+      const addEnv = await this.ui.promptConfirm({
+        message: 'В .gitignore нет .env. Добавить?',
+        default: true,
+      });
+
+      if (addEnv) {
+        additions.push('.env');
+      }
+    }
+
+    if (additions.length === 0) {
+      return;
+    }
+
+    const trimmed = content.trimEnd();
+    const next =
+      trimmed.length > 0
+        ? `${trimmed}\n${additions.join('\n')}`
+        : additions.join('\n');
+    await fs.writeFile(gitignorePath, `${next}\n`, 'utf8');
+    this.ui.log.success('Обновлен .gitignore');
+  }
+
+  private async fileExists(targetPath: string): Promise<boolean> {
+    try {
+      await fs.access(targetPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/commands/init/init.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { UiModule } from '../../core/ui/ui.module';
+import { InitCommand } from './init.command';
+
+@Module({
+  imports: [UiModule],
+  providers: [InitCommand],
+})
+export class InitModule {}

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

@@ -0,0 +1,167 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import clipboard from 'clipboardy';
+import { Command, CommandRunner, Option } from 'nest-commander';
+import { FsService } from '../../core/file-system/fs.service';
+import { UiService } from '../../core/ui/ui.service';
+import { TokenizerService } from '../../shared/tokenizer/tokenizer.service';
+
+type PackOptions = {
+  copy?: boolean;
+  template?: string;
+  out?: string;
+};
+
+type TemplateContext = {
+  context: string;
+  fileList: string;
+  tokenCount: number;
+  usdEstimate: number;
+};
+
+@Command({ name: 'pack', description: 'Собрать контекст проекта в один файл' })
+export class PackCommand extends CommandRunner {
+  constructor(
+    private readonly ui: UiService,
+    private readonly fsService: FsService,
+    private readonly tokenizer: TokenizerService,
+  ) {
+    super();
+  }
+
+  @Option({ flags: '-c, --copy', description: 'Скопировать результат в буфер' })
+  parseCopy(): boolean {
+    return true;
+  }
+
+  @Option({
+    flags: '-t, --template <name>',
+    description: 'Имя шаблона из .kodu/prompts',
+  })
+  parseTemplate(value: string): string {
+    return value;
+  }
+
+  @Option({
+    flags: '-o, --out <path>',
+    description: 'Путь для сохранения результата',
+  })
+  parseOut(value: string): string {
+    return value;
+  }
+
+  async run(_inputs: string[], options: PackOptions): Promise<void> {
+    const spinner = this.ui.createSpinner({ text: 'Сбор файлов...' }).start();
+
+    try {
+      const files = await this.fsService.findProjectFiles();
+
+      if (files.length === 0) {
+        spinner.stop('Нет файлов для упаковки.');
+        this.ui.log.warn('Нет файлов для упаковки.');
+        return;
+      }
+
+      const context = await this.buildContext(files);
+      const fileList = files.join('\n');
+      const { tokens, usdEstimate } = this.tokenizer.count(context);
+
+      const templateApplied = options.template
+        ? await this.applyTemplate(options.template, {
+            context,
+            fileList,
+            tokenCount: tokens,
+            usdEstimate,
+          })
+        : context;
+
+      const outputPath = await this.writeOutput(templateApplied, options.out);
+
+      if (options.copy) {
+        await clipboard.write(templateApplied);
+      }
+
+      spinner.success('Сбор завершен');
+      this.ui.log.info(`Файлов: ${files.length}`);
+      this.ui.log.info(`Токены: ${tokens}`);
+      this.ui.log.info(`Оценка стоимости: ~$${usdEstimate.toFixed(4)}`);
+      this.ui.log.success(`Сохранено в ${outputPath}`);
+
+      if (options.copy) {
+        this.ui.log.success('Результат скопирован в буфер обмена');
+      }
+    } catch (error) {
+      spinner.error('Ошибка при сборке контекста');
+      const message =
+        error instanceof Error ? error.message : 'Неизвестная ошибка';
+      this.ui.log.error(message);
+      process.exitCode = 1;
+    }
+  }
+
+  private async buildContext(files: string[]): Promise<string> {
+    const chunks = await Promise.all(
+      files.map(async (file) => {
+        const content = await this.fsService.readFileRelative(file);
+        return `// file: ${file}\n${content}`;
+      }),
+    );
+
+    return chunks.join('\n\n');
+  }
+
+  private async applyTemplate(
+    name: string,
+    ctx: TemplateContext,
+  ): Promise<string> {
+    const template = await this.loadTemplate(name);
+    const filled = template
+      .replace(/\{\{context\}\}/g, ctx.context)
+      .replace(/\{\{fileList\}\}/g, ctx.fileList)
+      .replace(/\{\{tokenCount\}\}/g, ctx.tokenCount.toString())
+      .replace(/\{\{usdEstimate\}\}/g, ctx.usdEstimate.toFixed(4));
+
+    if (!template.includes('{{context}}')) {
+      return `${filled}\n\n${ctx.context}`;
+    }
+
+    return filled;
+  }
+
+  private async loadTemplate(name: string): Promise<string> {
+    const base = path.join(process.cwd(), '.kodu', 'prompts', name);
+    const candidates = [`${base}.md`, `${base}.txt`];
+
+    for (const candidate of candidates) {
+      if (await this.fileExists(candidate)) {
+        return fs.readFile(candidate, 'utf8');
+      }
+    }
+
+    throw new Error(
+      `Шаблон ${name} не найден. Ожидались файлы: ${candidates
+        .map((c) => path.relative(process.cwd(), c))
+        .join(', ')}`,
+    );
+  }
+
+  private async writeOutput(
+    content: string,
+    outPath?: string,
+  ): Promise<string> {
+    const target = outPath ?? path.join(process.cwd(), '.kodu', 'context.txt');
+    const dir = path.dirname(target);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(target, `${content}\n`, 'utf8');
+    return target;
+  }
+
+  private async fileExists(filePath: string): Promise<boolean> {
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

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

@@ -0,0 +1,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 { TokenizerModule } from '../../shared/tokenizer/tokenizer.module';
+import { PackCommand } from './pack.command';
+
+@Module({
+  imports: [ConfigModule, UiModule, FsModule, TokenizerModule],
+  providers: [PackCommand],
+})
+export class PackModule {}

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

@@ -0,0 +1,266 @@
+import { writeFile } from 'node:fs/promises';
+import clipboard from 'clipboardy';
+import { Command, CommandRunner, Option } from 'nest-commander';
+import { UiService } from '../../core/ui/ui.service';
+import {
+  AiService,
+  type ReviewMode,
+  type ReviewResult,
+} from '../../shared/ai/ai.service';
+import { GitService } from '../../shared/git/git.service';
+import { TokenizerService } from '../../shared/tokenizer/tokenizer.service';
+
+type ReviewOptions = {
+  mode?: ReviewMode;
+  copy?: boolean;
+  json?: boolean;
+  ci?: boolean;
+  output?: string;
+};
+
+const DEFAULT_MODE: ReviewMode = 'bug';
+
+@Command({
+  name: 'review',
+  description: 'AI ревью для застейдженных изменений',
+})
+export class ReviewCommand extends CommandRunner {
+  constructor(
+    private readonly ui: UiService,
+    private readonly git: GitService,
+    private readonly tokenizer: TokenizerService,
+    private readonly ai: AiService,
+  ) {
+    super();
+  }
+
+  @Option({
+    flags: '-m, --mode <mode>',
+    description: 'Режим проверки: bug | style | security',
+  })
+  parseMode(value: string): ReviewMode {
+    if (value === 'bug' || value === 'style' || value === 'security') {
+      return value;
+    }
+    return DEFAULT_MODE;
+  }
+
+  @Option({ flags: '-c, --copy', description: 'Скопировать результат в буфер' })
+  parseCopy(): boolean {
+    return true;
+  }
+
+  @Option({
+    flags: '--json',
+    description: 'Вернуть JSON (структурированный вывод)',
+  })
+  parseJson(): boolean {
+    return true;
+  }
+
+  @Option({ flags: '--ci', description: 'CI-режим: без спиннера и без буфера' })
+  parseCi(): boolean {
+    return true;
+  }
+
+  @Option({
+    flags: '-o, --output <path>',
+    description: 'Сохранить итоговый ревью в файл (text/JSON)',
+  })
+  parseOutput(value: string): string {
+    return value;
+  }
+
+  async run(_inputs: string[], options: ReviewOptions = {}): Promise<void> {
+    const ciMode = Boolean(options.ci);
+    const spinner = ciMode
+      ? undefined
+      : this.ui.createSpinner({ text: 'Собираю diff из git...' }).start();
+
+    const logProgress = (text: string): void => {
+      if (ciMode) {
+        return;
+      }
+      if (spinner) {
+        spinner.text = text;
+        return;
+      }
+      this.ui.log.info(text);
+    };
+
+    const finishProgress = (text: string): void => {
+      if (ciMode) {
+        return;
+      }
+      if (spinner) {
+        spinner.success(text);
+        return;
+      }
+      this.ui.log.success(text);
+    };
+
+    try {
+      await this.git.ensureRepo();
+
+      const hasStaged = await this.git.hasStagedChanges();
+      if (!hasStaged) {
+        if (spinner) {
+          spinner.stop('Нет застейдженных изменений');
+        } else {
+          this.ui.log.info('Нет застейдженных изменений');
+        }
+        this.ui.log.warn('Сначала выполните git add для нужных файлов.');
+        return;
+      }
+
+      const diff = await this.git.getStagedDiff();
+      if (!diff.trim()) {
+        if (spinner) {
+          spinner.stop('Diff пуст — возможно, всё исключено packer.ignore');
+        } else {
+          this.ui.log.info('Diff пуст — возможно, всё исключено packer.ignore');
+        }
+        this.ui.log.warn(
+          'Diff пустой: все изменения попали в исключения packer.ignore.',
+        );
+        return;
+      }
+
+      const tokens = this.tokenizer.count(diff);
+      const warningBudget = 12000;
+      if (tokens.tokens > warningBudget) {
+        this.ui.log.warn(
+          `Большой контекст (${tokens.tokens} токенов, ~$${tokens.usdEstimate.toFixed(2)}). Ревью может стоить дороже.`,
+        );
+      }
+
+      logProgress('Запрос к AI...');
+      const mode = options.mode ?? DEFAULT_MODE;
+      const result = await this.ai.reviewDiff(
+        diff,
+        mode,
+        Boolean(options.json),
+      );
+
+      finishProgress('Ревью готово');
+
+      if (options.json && result.structured) {
+        this.renderStructured(result.structured, ciMode);
+        await this.writeOutput(options.output, result.structured, ciMode);
+        if (options.copy) {
+          await this.copyJson(result.structured, ciMode);
+        }
+        this.failIfIssues(result.structured, ciMode);
+        return;
+      }
+
+      if (options.json && !result.structured) {
+        this.ui.log.warn(
+          'Структурированный вывод недоступен, показываю текст.',
+        );
+      }
+
+      console.log(result.text);
+      await this.writeOutput(options.output, result.text, ciMode);
+
+      if (options.copy) {
+        await this.copyText(result.text, ciMode);
+      }
+      this.failIfIssues(result.structured, ciMode);
+    } catch (error) {
+      if (spinner) {
+        spinner.error('Ошибка ревью');
+      } else {
+        this.ui.log.error('Ошибка ревью');
+      }
+      const message =
+        error instanceof Error ? error.message : 'Неизвестная ошибка';
+      this.ui.log.error(message);
+      process.exitCode = 1;
+    }
+  }
+
+  private async writeOutput(
+    target: string | undefined,
+    payload: unknown,
+    ciMode?: boolean,
+  ): Promise<void> {
+    if (!target) {
+      return;
+    }
+    const data =
+      typeof payload === 'string' ? payload : JSON.stringify(payload, null, 2);
+    await writeFile(target, data, { encoding: 'utf8' });
+    if (!ciMode) {
+      this.ui.log.success(`Результат сохранён в ${target}`);
+    }
+  }
+
+  private async copyJson(result: ReviewResult, ciMode: boolean): Promise<void> {
+    if (ciMode) {
+      this.ui.log.warn('--copy игнорируется в CI режиме');
+      return;
+    }
+    await clipboard.write(JSON.stringify(result, null, 2));
+    this.ui.log.success('JSON скопирован в буфер обмена');
+  }
+
+  private async copyText(text: string, ciMode: boolean): Promise<void> {
+    if (ciMode) {
+      this.ui.log.warn('--copy игнорируется в CI режиме');
+      return;
+    }
+    await clipboard.write(text);
+    this.ui.log.success('Результат скопирован в буфер обмена');
+  }
+
+  private failIfIssues(
+    structured: ReviewResult | undefined,
+    ciMode: boolean,
+  ): void {
+    const issues = structured?.issues ?? [];
+    if (!issues.length) {
+      return;
+    }
+    const message = 'AI нашёл проблемы — ревью фейлится.';
+    if (ciMode) {
+      console.error(message);
+    } else {
+      this.ui.log.error(message);
+    }
+    process.exitCode = 1;
+  }
+
+  private renderStructured(result: ReviewResult, ciMode: boolean): void {
+    if (ciMode) {
+      console.log(`Итог: ${result.summary}`);
+      if (!result.issues.length) {
+        return;
+      }
+      result.issues.forEach((issue) => {
+        const location = [issue.file, issue.line ? `:${issue.line}` : '']
+          .filter(Boolean)
+          .join('');
+        console.log(
+          `- [${issue.severity}] ${location ? `${location} ` : ''}${issue.message}`,
+        );
+      });
+      return;
+    }
+
+    this.ui.log.info(`Итог: ${result.summary}`);
+    if (!result.issues.length) {
+      this.ui.log.success('Критичных проблем не найдено.');
+      return;
+    }
+
+    result.issues.forEach((issue) => {
+      const location = [issue.file, issue.line ? `:${issue.line}` : '']
+        .filter(Boolean)
+        .join('');
+      console.log(
+        `- [${issue.severity}] ${location ? `${location} ` : ''}${issue.message}`,
+      );
+    });
+  }
+}

package/src/commands/review/review.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '../../core/config/config.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';
+import { ReviewCommand } from './review.command';
+
+@Module({
+  imports: [ConfigModule, UiModule, GitModule, TokenizerModule, AiModule],
+  providers: [ReviewCommand],
+})
+export class ReviewModule {}

package/src/core/config/config.module.ts

@@ -0,0 +1,9 @@
+import { Global, Module } from '@nestjs/common';
+import { ConfigService } from './config.service';
+
+@Global()
+@Module({
+  providers: [ConfigService],
+  exports: [ConfigService],
+})
+export class ConfigModule {}