kodu 1.1.2 → 1.1.4

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

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+
+const llmSchema = z.object({
+  provider: z.literal('openai').default('openai'),
+  model: z.string().default('gpt-4o'),
+  apiKeyEnv: z.string().default('OPENAI_API_KEY'),
+});
+
+const cleanerSchema = z.object({
+  whitelist: z.array(z.string()).default(['//!']),
+  keepJSDoc: z.boolean().default(true),
+});
+
+const packerSchema = z.object({
+  ignore: z
+    .array(z.string())
+    .default([
+      'package-lock.json',
+      'yarn.lock',
+      'pnpm-lock.yaml',
+      '.git',
+      '.kodu',
+      'node_modules',
+      'dist',
+      'coverage',
+    ]),
+});
+
+export const configSchema = z.object({
+  llm: llmSchema.default({
+    provider: 'openai',
+    model: 'gpt-4o',
+    apiKeyEnv: 'OPENAI_API_KEY',
+  }),
+  cleaner: cleanerSchema.default({ whitelist: ['//!'], keepJSDoc: true }),
+  packer: packerSchema.default({
+    ignore: [
+      'package-lock.json',
+      'yarn.lock',
+      'pnpm-lock.yaml',
+      '.git',
+      '.kodu',
+      'node_modules',
+      'dist',
+      'coverage',
+    ],
+  }),
+});
+
+export type KoduConfig = z.infer<typeof configSchema>;

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

@@ -0,0 +1,46 @@
+import { Injectable } from '@nestjs/common';
+import { lilconfigSync } from 'lilconfig';
+import pc from 'picocolors';
+import { configSchema, type KoduConfig } from './config.schema';
+
+@Injectable()
+export class ConfigService {
+  private config?: KoduConfig;
+
+  getConfig(): KoduConfig {
+    if (!this.config) {
+      this.config = this.loadConfig();
+    }
+
+    return this.config;
+  }
+
+  private loadConfig(): KoduConfig {
+    const explorer = lilconfigSync('kodu', { searchPlaces: ['kodu.json'] });
+    const result = explorer.search(process.cwd());
+
+    if (!result || result.isEmpty || !result.config) {
+      this.terminate(
+        'Не найден конфиг kodu.json. Запустите `kodu init`, чтобы создать файл.',
+      );
+    }
+
+    const parsed = configSchema.safeParse(result.config);
+
+    if (!parsed.success) {
+      console.error(pc.red('Конфиг kodu.json невалиден:'));
+      parsed.error.issues.forEach((issue) => {
+        const path = issue.path.join('.') || '(root)';
+        console.error(pc.red(`- ${path}: ${issue.message}`));
+      });
+      this.terminate('Исправьте конфиг и запустите команду снова.');
+    }
+
+    return parsed.data;
+  }
+
+  private terminate(message: string): never {
+    console.error(pc.red(message));
+    process.exit(1);
+  }
+}

package/src/core/config/config.types.ts

@@ -0,0 +1 @@
+export type { KoduConfig } from './config.schema';

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

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { FsService } from './fs.service';
+
+@Module({
+  providers: [FsService],
+  exports: [FsService],
+})
+export class FsModule {}

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

@@ -0,0 +1,44 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { Injectable } from '@nestjs/common';
+import { glob } from 'tinyglobby';
+import { ConfigService } from '../config/config.service';
+
+@Injectable()
+export class FsService {
+  constructor(private readonly configService: ConfigService) {}
+
+  async findProjectFiles(): Promise<string[]> {
+    const { packer } = this.configService.getConfig();
+    const gitignore = await this.readGitignorePatterns();
+    const entries = await glob(['**/*'], {
+      onlyFiles: true,
+      absolute: true,
+      ignore: [...packer.ignore, ...gitignore],
+    });
+
+    return entries
+      .map((entry) => path.relative(process.cwd(), entry))
+      .filter((relative) => relative.length > 0)
+      .sort((a, b) => a.localeCompare(b));
+  }
+
+  async readFileRelative(relativePath: string): Promise<string> {
+    const absolute = path.resolve(process.cwd(), relativePath);
+    return fs.readFile(absolute, 'utf8');
+  }
+
+  private async readGitignorePatterns(): Promise<string[]> {
+    const gitignorePath = path.join(process.cwd(), '.gitignore');
+
+    try {
+      const content = await fs.readFile(gitignorePath, 'utf8');
+      return content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !line.startsWith('#'));
+    } catch {
+      return [];
+    }
+  }
+}

package/src/core/ui/ui.module.ts

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

package/src/core/ui/ui.service.ts

@@ -0,0 +1,39 @@
+import confirm from '@inquirer/confirm';
+import input from '@inquirer/input';
+import select from '@inquirer/select';
+import { Injectable } from '@nestjs/common';
+import pc from 'picocolors';
+import yoctoSpinner, {
+  type Spinner,
+  type Options as SpinnerOptions,
+} from 'yocto-spinner';
+
+type InputOptions = Parameters<typeof input>[0];
+type ConfirmOptions = Parameters<typeof confirm>[0];
+type SelectOptions<TValue> = Parameters<typeof select<TValue>>[0];
+
+@Injectable()
+export class UiService {
+  readonly log = {
+    success: (message: string) => console.log(pc.green(`✔ ${message}`)),
+    warn: (message: string) => console.log(pc.yellow(`⚠ ${message}`)),
+    error: (message: string) => console.log(pc.red(`✖ ${message}`)),
+    info: (message: string) => console.log(pc.cyan(`ℹ ${message}`)),
+  };
+
+  createSpinner(options?: SpinnerOptions & { text?: string }): Spinner {
+    return yoctoSpinner({ text: options?.text ?? '', ...options });
+  }
+
+  promptInput(options: InputOptions): Promise<string> {
+    return input(options);
+  }
+
+  promptConfirm(options: ConfirmOptions): Promise<boolean> {
+    return confirm(options);
+  }
+
+  promptSelect<TValue>(options: SelectOptions<TValue>): Promise<TValue> {
+    return select<TValue>(options);
+  }
+}

package/src/main.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import { CommandFactory } from 'nest-commander';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  await CommandFactory.run(AppModule);
+}
+bootstrap();

package/src/shared/ai/ai.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '../../core/config/config.module';
+import { AiService } from './ai.service';
+
+@Module({
+  imports: [ConfigModule],
+  providers: [AiService],
+  exports: [AiService],
+})
+export class AiModule {}

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

@@ -0,0 +1,160 @@
+import { Agent } from '@mastra/core/agent';
+import { Injectable } from '@nestjs/common';
+import { z } from 'zod';
+import { ConfigService } from '../../core/config/config.service';
+
+export type ReviewMode = 'bug' | 'style' | 'security';
+
+type ReviewIssue = {
+  severity: 'low' | 'medium' | 'high';
+  file?: string;
+  line?: number;
+  message: string;
+};
+
+export type ReviewResult = {
+  summary: string;
+  issues: ReviewIssue[];
+};
+
+@Injectable()
+export class AiService {
+  constructor(private readonly configService: ConfigService) {}
+
+  async reviewDiff(
+    diff: string,
+    mode: ReviewMode,
+    structured: boolean,
+  ): Promise<{ text: string; structured?: ReviewResult }> {
+    const agent = this.createAgent(
+      'kodu-review-agent',
+      'AI Reviewer for staged git diff. Be concise.',
+    );
+
+    const userPrompt = this.buildReviewPrompt(diff, mode);
+
+    if (structured) {
+      const schema = z.object({
+        summary: z.string(),
+        issues: z
+          .array(
+            z.object({
+              severity: z.enum(['low', 'medium', 'high']).default('low'),
+              file: z.string().optional(),
+              line: z.number().int().positive().optional(),
+              message: z.string(),
+            }),
+          )
+          .default([]),
+      });
+
+      const output = await agent.generate(userPrompt, {
+        structuredOutput: { schema },
+      });
+
+      return { text: output.text.trim(), structured: output.object };
+    }
+
+    const output = await agent.generate(userPrompt);
+    return { text: output.text.trim() };
+  }
+
+  async generateCommitMessage(diff: string): Promise<string> {
+    const agent = this.createAgent(
+      'kodu-commit-agent',
+      'Generate a concise Conventional Commit message. Only output the message string.',
+    );
+
+    const output = await agent.generate(
+      `
+You generate Conventional Commit messages.
+Rules:
+- Format: <type>(<optional scope>): <subject>
+- Lowercase subject, no trailing period.
+- Keep under 70 characters.
+- Summarize the diff accurately.
+
+Diff:
+${diff}
+`.trim(),
+    );
+
+    const raw = output.text.trim();
+    const cleaned = this.cleanCommitMessage(raw);
+
+    if (!cleaned) {
+      throw new Error('AI не вернул валидное сообщение коммита.');
+    }
+
+    return cleaned;
+  }
+
+  private createAgent(id: string, instructions: string): Agent {
+    const apiKey = this.getApiKey();
+    const modelId = this.getModelId();
+
+    return new Agent({
+      id,
+      name: id,
+      instructions,
+      model: { id: modelId as `${string}/${string}`, apiKey },
+      maxRetries: 1,
+    });
+  }
+
+  private buildReviewPrompt(diff: string, mode: ReviewMode): string {
+    const focusByMode: Record<ReviewMode, string> = {
+      bug: 'Найди потенциальные баги, логические ошибки, регрессы.',
+      style: 'Проверь читаемость, согласованность, форматирование и нейминг.',
+      security:
+        'Найди уязвимости, утечки секретов, неправильные проверки прав.',
+    };
+
+    return `
+Ты — строгий ревьюер кода. Формат ответа: краткий markdown с пунктами.
+Режим: ${mode}. ${focusByMode[mode]}
+Дай сжатый список проблем и рекомендаций. Если критичных нет — скажи об этом.
+
+Diff:
+${diff}
+`.trim();
+  }
+
+  private getApiKey(): string {
+    const envName =
+      this.configService.getConfig().llm.apiKeyEnv ?? 'OPENAI_API_KEY';
+    const value = process.env[envName];
+
+    if (!value) {
+      throw new Error(`Не найден API ключ: установите ${envName} в окружении.`);
+    }
+
+    return value;
+  }
+
+  private getModelId(): string {
+    const model = this.configService.getConfig().llm.model;
+    const normalized = model.includes('/') ? model : `openai/${model}`;
+    return normalized;
+  }
+
+  private cleanCommitMessage(text: string): string {
+    const unfenced = text.replace(/^```[a-zA-Z]*\s*/g, '').replace(/```$/g, '');
+    const lines = unfenced
+      .split('\n')
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0);
+
+    if (lines.length === 0) {
+      return '';
+    }
+
+    const first = lines[0]
+      .replace(/^"|"$/g, '')
+      .replace(/^'|'$/g, '')
+      .replace(/^Commit message:?\s*/i, '')
+      .trim();
+
+    return first;
+  }
+}

package/src/shared/cleaner/cleaner.service.ts

@@ -0,0 +1,227 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { Injectable } from '@nestjs/common';
+import { Project, type SourceFile, SyntaxKind, ts } from 'ts-morph';
+import { ConfigService } from '../../core/config/config.service';
+import { FsService } from '../../core/file-system/fs.service';
+import {
+  type CleanOptions,
+  type CleanSummary,
+  type FileCleanReport,
+} from './cleaner.types';
+
+type RemovalRange = {
+  start: number;
+  end: number;
+  text: string;
+  kind: 'comment' | 'jsx';
+};
+
+@Injectable()
+export class CleanerService {
+  private readonly project = new Project({
+    useInMemoryFileSystem: false,
+    skipFileDependencyResolution: true,
+    compilerOptions: {
+      allowJs: true,
+      jsx: ts.JsxEmit.Preserve,
+    },
+  });
+
+  private readonly systemWhitelist = [
+    '@ts-ignore',
+    '@ts-expect-error',
+    'eslint-disable',
+    'prettier-ignore',
+    'biome-ignore',
+    'todo',
+    'fixme',
+  ];
+
+  constructor(
+    private readonly configService: ConfigService,
+    private readonly fsService: FsService,
+  ) {}
+
+  async cleanFiles(
+    files: string[],
+    options: CleanOptions = {},
+  ): Promise<CleanSummary> {
+    const config = this.configService.getConfig();
+    const whitelist = this.buildWhitelist(config.cleaner.whitelist);
+    let commentsRemoved = 0;
+    let filesChanged = 0;
+    const reports: FileCleanReport[] = [];
+
+    for (const file of files) {
+      const original = await this.fsService.readFileRelative(file);
+      const result = this.cleanSource(
+        file,
+        original,
+        whitelist,
+        config.cleaner.keepJSDoc,
+      );
+
+      if (result.removed > 0) {
+        filesChanged += 1;
+        commentsRemoved += result.removed;
+
+        if (!options.dryRun) {
+          await this.writeFile(file, result.nextContent);
+        }
+      }
+
+      reports.push({
+        file,
+        removed: result.removed,
+        previews: result.previews,
+      });
+    }
+
+    return {
+      filesProcessed: files.length,
+      filesChanged,
+      commentsRemoved,
+      reports,
+    };
+  }
+
+  private cleanSource(
+    file: string,
+    content: string,
+    whitelist: Set<string>,
+    keepJSDoc: boolean,
+  ): { nextContent: string; removed: number; previews: string[] } {
+    const sourceFile = this.project.createSourceFile(file, content, {
+      overwrite: true,
+    });
+    const fullText = sourceFile.getFullText();
+
+    const ranges = this.collectCommentRanges(sourceFile);
+    const candidates = ranges.filter((range) =>
+      this.shouldRemove(range, whitelist, keepJSDoc),
+    );
+
+    if (candidates.length === 0) {
+      return { nextContent: content, removed: 0, previews: [] };
+    }
+
+    const previews = candidates
+      .slice(0, 3)
+      .map((range) => this.normalizePreview(range.text));
+
+    const sorted = [...candidates].sort((a, b) => b.start - a.start);
+    let nextContent = fullText;
+
+    for (const range of sorted) {
+      const replacement = this.getReplacement(fullText, range);
+      nextContent = `${nextContent.slice(0, range.start)}${replacement}${nextContent.slice(range.end)}`;
+    }
+
+    return { nextContent, removed: candidates.length, previews };
+  }
+
+  private collectCommentRanges(sourceFile: SourceFile): RemovalRange[] {
+    const fullText = sourceFile.getFullText();
+    const ranges = new Map<string, RemovalRange>();
+
+    const addRanges = (items: readonly ts.CommentRange[] | undefined) => {
+      if (!items) return;
+
+      for (const item of items) {
+        const key = `${item.pos}:${item.end}`;
+        if (ranges.has(key)) continue;
+        ranges.set(key, {
+          start: item.pos,
+          end: item.end,
+          text: fullText.slice(item.pos, item.end),
+          kind: 'comment',
+        });
+      }
+    };
+
+    const visit = (node: ts.Node): void => {
+      addRanges(ts.getLeadingCommentRanges(fullText, node.getFullStart()));
+      addRanges(ts.getTrailingCommentRanges(fullText, node.getEnd()));
+      ts.forEachChild(node, visit);
+    };
+
+    visit(sourceFile.compilerNode);
+
+    const jsxExpressions = sourceFile.getDescendantsOfKind(
+      SyntaxKind.JsxExpression,
+    );
+    for (const jsx of jsxExpressions) {
+      if (jsx.getExpression()) continue;
+      const text = jsx.getText();
+      if (!text.includes('/*')) continue;
+
+      const start = jsx.getPos();
+      const end = jsx.getEnd();
+      const key = `${start}:${end}`;
+
+      if (!ranges.has(key)) {
+        ranges.set(key, {
+          start,
+          end,
+          text: fullText.slice(start, end),
+          kind: 'jsx',
+        });
+      }
+    }
+
+    return [...ranges.values()];
+  }
+
+  private shouldRemove(
+    range: RemovalRange,
+    whitelist: Set<string>,
+    keepJSDoc: boolean,
+  ): boolean {
+    const trimmed = range.text.trimStart();
+    if (keepJSDoc && trimmed.startsWith('/**')) {
+      return false;
+    }
+
+    const lower = range.text.toLowerCase();
+    for (const token of whitelist) {
+      if (lower.includes(token)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  private normalizePreview(text: string): string {
+    const singleLine = text.replace(/\s+/g, ' ').trim();
+    if (singleLine.length <= 50) return singleLine;
+    return `${singleLine.slice(0, 47)}...`;
+  }
+
+  private getReplacement(original: string, range: RemovalRange): string {
+    if (range.kind === 'jsx') {
+      return '';
+    }
+
+    const before = range.start > 0 ? original[range.start - 1] : '';
+    const after = range.end < original.length ? original[range.end] : '';
+    const isIdentifier = (ch: string): boolean => /[A-Za-z0-9_$]/.test(ch);
+
+    if (isIdentifier(before) && isIdentifier(after)) {
+      return ' ';
+    }
+
+    return '';
+  }
+
+  private buildWhitelist(userList: string[]): Set<string> {
+    const normalized = userList.map((item) => item.toLowerCase());
+    return new Set([...this.systemWhitelist, ...normalized]);
+  }
+
+  private async writeFile(file: string, content: string): Promise<void> {
+    const absolute = path.resolve(process.cwd(), file);
+    await fs.writeFile(absolute, content, 'utf8');
+  }
+}

package/src/shared/cleaner/cleaner.types.ts

@@ -0,0 +1,16 @@
+export type CleanOptions = {
+  dryRun?: boolean;
+};
+
+export type FileCleanReport = {
+  file: string;
+  removed: number;
+  previews: string[];
+};
+
+export type CleanSummary = {
+  filesProcessed: number;
+  filesChanged: number;
+  commentsRemoved: number;
+  reports: FileCleanReport[];
+};

package/src/shared/git/git.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '../../core/config/config.module';
+import { GitService } from './git.service';
+
+@Module({
+  imports: [ConfigModule],
+  providers: [GitService],
+  exports: [GitService],
+})
+export class GitModule {}

package/src/shared/git/git.service.ts

@@ -0,0 +1,49 @@
+import { Injectable } from '@nestjs/common';
+import { execa } from 'execa';
+import { ConfigService } from '../../core/config/config.service';
+
+const EXCLUDE_PREFIX = ':(exclude)';
+
+@Injectable()
+export class GitService {
+  constructor(private readonly configService: ConfigService) {}
+
+  async ensureRepo(): Promise<void> {
+    try {
+      await execa('git', ['rev-parse', '--is-inside-work-tree']);
+    } catch (error) {
+      const message =
+        error instanceof Error && 'stdout' in error
+          ? String((error as { stderr?: string }).stderr ?? error.message)
+          : 'Git репозиторий не найден. Инициализируйте git перед выполнением команды.';
+      throw new Error(message);
+    }
+  }
+
+  async hasStagedChanges(): Promise<boolean> {
+    const { stdout } = await execa('git', ['diff', '--staged', '--name-only']);
+    return stdout.trim().length > 0;
+  }
+
+  async getStagedDiff(): Promise<string> {
+    await this.ensureRepo();
+    const excludeArgs = this.buildExcludeArgs();
+    const args = ['diff', '--staged', '--unified=3', '--', '.', ...excludeArgs];
+    const { stdout } = await execa('git', args);
+    return stdout;
+  }
+
+  async getStatusShort(): Promise<string> {
+    const { stdout } = await execa('git', ['status', '--short']);
+    return stdout.trim();
+  }
+
+  async commit(message: string): Promise<void> {
+    await execa('git', ['commit', '-m', message]);
+  }
+
+  private buildExcludeArgs(): string[] {
+    const ignore = this.configService.getConfig().packer.ignore ?? [];
+    return ignore.map((pattern) => `${EXCLUDE_PREFIX}${pattern}`);
+  }
+}