kodu 2.0.0 → 2.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodu",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "High-performance CLI to prepare codebase for LLMs, automate reviews, and draft commits.",
   "repository": {
     "type": "git",

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

@@ -1,3 +1,4 @@
+import { createReadStream } from 'node:fs';
 import { Command, CommandRunner, Option } from 'nest-commander';
 import { ConfigService } from '../../core/config/config.service';
 import { FsService } from '../../core/file-system/fs.service';
@@ -5,9 +6,16 @@ import { UiService } from '../../core/ui/ui.service';
 import { CleanerService } from '../../shared/cleaner/cleaner.service';
 import { GitService } from '../../shared/git/git.service';
 
+const SUPPORTED_EXTENSIONS = /\.(ts|tsx|js|jsx|mjs|cjs|html|htm)$/i;
+
 type CleanOptions = {
   dryRun?: boolean;
   changed?: boolean;
+  staged?: boolean;
+  backup?: boolean;
+  noJsdoc?: boolean;
+  verbose?: boolean;
+  stdin?: boolean;
 };
 
 @Command({ name: 'clean', description: 'Remove comments from code' })
@@ -22,23 +30,65 @@ export class CleanCommand extends CommandRunner {
     super();
   }
 
-  @Option({
-    flags: '-d, --dry-run',
-    description: 'Show what will be removed',
-  })
+  @Option({ flags: '-d, --dry-run', description: 'Show what will be removed' })
   parseDryRun(): boolean {
     return true;
   }
 
   @Option({
     flags: '-c, --changed',
-    description: 'Clean only changed files',
+    description: 'Clean only git-changed files (staged + unstaged + untracked)',
   })
   parseChanged(): boolean {
     return true;
   }
 
-  async run(_inputs: string[], options: CleanOptions = {}): Promise<void> {
+  @Option({
+    flags: '-s, --staged',
+    description: 'Clean only git-staged files',
+  })
+  parseStaged(): boolean {
+    return true;
+  }
+
+  @Option({
+    flags: '-b, --backup',
+    description: 'Save originals to .kodu/backup/ before modifying',
+  })
+  parseBackup(): boolean {
+    return true;
+  }
+
+  @Option({
+    flags: '-n, --no-jsdoc',
+    description: 'Remove JSDoc comments (overrides config keepJSDoc)',
+  })
+  parseNoJsdoc(): boolean {
+    return true;
+  }
+
+  @Option({
+    flags: '-v, --verbose',
+    description: 'Show all removed comments in dry-run (not just first 3)',
+  })
+  parseVerbose(): boolean {
+    return true;
+  }
+
+  @Option({
+    flags: '--stdin',
+    description: 'Read from stdin, write cleaned result to stdout',
+  })
+  parseStdin(): boolean {
+    return true;
+  }
+
+  async run(inputs: string[], options: CleanOptions = {}): Promise<void> {
+    if (options.stdin) {
+      await this.runStdin(options);
+      return;
+    }
+
     const spinner = this.ui
       .createSpinner({ text: this.buildSpinnerText(options) })
       .start();
@@ -53,45 +103,62 @@ export class CleanCommand extends CommandRunner {
         useGitignore: cleanerConfig.useGitignore,
         ignore: ignorePatterns,
       });
-      const targets = await this.collectTargets(allFiles, options);
+
+      const targets = await this.collectTargets(allFiles, inputs, options);
 
       if (targets.length === 0) {
-        const noFilesMessage = options.changed
-          ? 'No changed files to clean.'
-          : 'No files to clean.';
-        spinner.stop(noFilesMessage);
-        this.ui.log.warn(noFilesMessage);
+        const msg = this.noFilesMessage(options);
+        spinner.stop(msg);
+        this.ui.log.warn(msg);
         return;
       }
 
       const summary = await this.cleaner.cleanFiles(targets, {
         dryRun: options.dryRun,
+        backup: options.backup,
+        keepJSDoc: options.noJsdoc ? false : undefined,
+        onProgress: (current, total) => {
+          spinner.text = `${this.buildSpinnerText(options)} (${current}/${total})`;
+        },
       });
 
       spinner.success(
         options.dryRun ? 'Analysis complete' : 'Cleaning complete',
       );
 
+      const bytesSaved = summary.bytesBefore - summary.bytesAfter;
+      const tokensSaved = Math.round(bytesSaved / 4);
+
       if (options.dryRun) {
         this.ui.log.info(
-          `Files to be affected: ${summary.filesChanged}, comments: ${summary.commentsRemoved}`,
+          `Files affected: ${summary.filesChanged}/${summary.filesProcessed}, comments: ${summary.commentsRemoved}`,
         );
-        summary.reports
-          .filter((report) => report.removed > 0)
-          .forEach((report) => {
-            const previews = report.previews
-              .map((item) => `"${item}"`)
-              .join(', ');
-            this.ui.log.info(
-              `- ${report.file} (${report.removed}): ${previews}`,
-            );
-          });
+        this.ui.log.info(`Bytes saved: ${bytesSaved} (~${tokensSaved} tokens)`);
+
+        const limit = options.verbose ? Number.POSITIVE_INFINITY : 3;
+        for (const report of summary.reports.filter((r) => r.removed > 0)) {
+          const previews = options.verbose
+            ? report.previews
+            : report.previews.slice(0, limit);
+          const more =
+            !options.verbose && report.previews.length > limit
+              ? ` +${report.previews.length - limit} more`
+              : '';
+          this.ui.log.info(
+            `  ${report.file} (${report.removed}): ${previews.map((p) => `"${p}"`).join(', ')}${more}`,
+          );
+        }
         return;
       }
 
       this.ui.log.success(
         `Files cleaned: ${summary.filesChanged}, comments removed: ${summary.commentsRemoved}`,
       );
+      this.ui.log.info(`Bytes saved: ${bytesSaved} (~${tokensSaved} tokens)`);
+
+      if (options.backup && summary.filesChanged > 0) {
+        this.ui.log.info('Originals backed up to .kodu/backup/');
+      }
     } catch (error) {
       spinner.error('Error during cleaning');
       const message = error instanceof Error ? error.message : 'Unknown error';
@@ -100,26 +167,69 @@ export class CleanCommand extends CommandRunner {
     }
   }
 
+  private async runStdin(options: CleanOptions): Promise<void> {
+    try {
+      const input = await this.readStdin();
+      const cleaned = this.cleaner.cleanContent(
+        'stdin.ts',
+        input,
+        options.noJsdoc ? false : undefined,
+      );
+      process.stdout.write(cleaned);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      this.ui.log.error(message);
+      process.exitCode = 1;
+    }
+  }
+
+  private readStdin(): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      const stream = createReadStream('/dev/stdin');
+      stream.on('data', (chunk) =>
+        chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk),
+      );
+      stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+      stream.on('error', reject);
+    });
+  }
+
   private buildSpinnerText(options: CleanOptions): string {
-    const action = options.dryRun ? 'Analysis' : 'Cleaning';
-    const target = options.changed ? ' changed files' : ' comments';
-    return `${action}${target}...`;
+    if (options.staged) return 'Cleaning staged files...';
+    if (options.changed) return 'Cleaning changed files...';
+    return options.dryRun ? 'Analysing...' : 'Cleaning...';
+  }
+
+  private noFilesMessage(options: CleanOptions): string {
+    if (options.staged) return 'No staged files to clean.';
+    if (options.changed) return 'No changed files to clean.';
+    return 'No files to clean.';
   }
 
   private async collectTargets(
     allFiles: string[],
+    inputs: string[],
     options: CleanOptions,
   ): Promise<string[]> {
-    const matcher = /\.(ts|tsx|js|jsx|html)$/i;
-    const filtered = allFiles.filter((file) => matcher.test(file));
+    const supported = allFiles.filter((f) => SUPPORTED_EXTENSIONS.test(f));
+
+    if (inputs.length > 0) {
+      return supported.filter((f) =>
+        inputs.some((i) => f === i || f.startsWith(`${i.replace(/\/$/, '')}/`)),
+      );
+    }
 
-    if (!options.changed) {
-      return filtered;
+    if (options.staged) {
+      const staged = new Set(await this.git.getStagedFiles());
+      return supported.filter((f) => staged.has(f));
     }
 
-    const changedFiles = await this.git.getChangedFiles();
-    const changedSet = new Set(changedFiles);
+    if (options.changed) {
+      const changed = new Set(await this.git.getChangedFiles());
+      return supported.filter((f) => changed.has(f));
+    }
 
-    return filtered.filter((file) => changedSet.has(file));
+    return supported;
   }
 }

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

@@ -6,6 +6,7 @@ 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';
@@ -18,6 +19,7 @@ type PackOptions = {
   exclude?: string[];
   list?: boolean;
   format?: OutputFormat;
+  clean?: boolean;
 };
 
 type TemplateContext = {
@@ -38,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();
   }
@@ -87,6 +90,14 @@ export class PackCommand extends CommandRunner {
     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',
@@ -130,7 +141,7 @@ export class PackCommand extends CommandRunner {
       }
 
       const format: OutputFormat = options.format ?? 'xml';
-      const context = await this.buildContext(files, format);
+      const context = await this.buildContext(files, format, options.clean);
       const fileList = files.join('\n');
       const { tokens, usdEstimate } = this.tokenizer.count(context);
 
@@ -160,7 +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}`);
+      this.ui.log.info(
+        `Format: ${format}${options.clean ? ' (comments stripped)' : ''}`,
+      );
       this.ui.log.success(`Saved to ${outputPath}`);
 
       if (options.copy) {
@@ -177,10 +190,14 @@ export class PackCommand extends CommandRunner {
   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>`;
         }

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/shared/cleaner/cleaner.service.ts

@@ -43,30 +43,50 @@ export class CleanerService {
     private readonly fsService: FsService,
   ) {}
 
+  cleanContent(filename: string, content: string, keepJSDoc?: boolean): string {
+    const config = this.configService.getConfig();
+    const whitelist = this.buildWhitelist(config.cleaner.whitelist);
+    const shouldKeepJSDoc = keepJSDoc ?? config.cleaner.keepJSDoc;
+    const result = this.cleanSource(
+      filename,
+      content,
+      whitelist,
+      shouldKeepJSDoc,
+    );
+    return result.nextContent;
+  }
+
   async cleanFiles(
     files: string[],
     options: CleanOptions = {},
   ): Promise<CleanSummary> {
     const config = this.configService.getConfig();
     const whitelist = this.buildWhitelist(config.cleaner.whitelist);
+    const keepJSDoc = options.keepJSDoc ?? config.cleaner.keepJSDoc;
     let commentsRemoved = 0;
     let filesChanged = 0;
+    let bytesBefore = 0;
+    let bytesAfter = 0;
     const reports: FileCleanReport[] = [];
 
-    for (const file of files) {
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i] as string;
+      options.onProgress?.(i + 1, files.length);
+
       const original = await this.fsService.readFileRelative(file);
-      const result = this.cleanSource(
-        file,
-        original,
-        whitelist,
-        config.cleaner.keepJSDoc,
-      );
+      bytesBefore += Buffer.byteLength(original, 'utf8');
+
+      const result = this.cleanSource(file, original, whitelist, keepJSDoc);
+      bytesAfter += Buffer.byteLength(result.nextContent, 'utf8');
 
       if (result.removed > 0) {
         filesChanged += 1;
         commentsRemoved += result.removed;
 
         if (!options.dryRun) {
+          if (options.backup) {
+            await this.backupFile(file, original);
+          }
           await this.writeFile(file, result.nextContent);
         }
       }
@@ -75,6 +95,8 @@ export class CleanerService {
         file,
         removed: result.removed,
         previews: result.previews,
+        bytesBefore: Buffer.byteLength(original, 'utf8'),
+        bytesAfter: Buffer.byteLength(result.nextContent, 'utf8'),
       });
     }
 
@@ -82,6 +104,8 @@ export class CleanerService {
       filesProcessed: files.length,
       filesChanged,
       commentsRemoved,
+      bytesBefore,
+      bytesAfter,
       reports,
     };
   }
@@ -106,9 +130,9 @@ export class CleanerService {
       return { nextContent: content, removed: 0, previews: [] };
     }
 
-    const previews = candidates
-      .slice(0, 3)
-      .map((range) => this.normalizePreview(range.text));
+    const previews = candidates.map((range) =>
+      this.normalizePreview(range.text),
+    );
 
     const sorted = [...candidates].sort((a, b) => b.start - a.start);
     let nextContent = fullText;
@@ -191,8 +215,8 @@ export class CleanerService {
 
   private normalizePreview(text: string): string {
     const singleLine = text.replace(/\s+/g, ' ').trim();
-    if (singleLine.length <= 50) return singleLine;
-    return `${singleLine.slice(0, 47)}...`;
+    if (singleLine.length <= 60) return singleLine;
+    return `${singleLine.slice(0, 57)}...`;
   }
 
   private getReplacement(original: string, range: RemovalRange): string {
@@ -221,6 +245,13 @@ export class CleanerService {
     await fs.writeFile(absolute, content, 'utf8');
   }
 
+  private async backupFile(file: string, content: string): Promise<void> {
+    const backupDir = path.join(process.cwd(), '.kodu', 'backup');
+    const target = path.join(backupDir, file);
+    await fs.mkdir(path.dirname(target), { recursive: true });
+    await fs.writeFile(target, content, 'utf8');
+  }
+
   private addRange(
     ranges: Map<string, RemovalRange>,
     start: number,

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

@@ -1,16 +1,23 @@
 export type CleanOptions = {
   dryRun?: boolean;
+  backup?: boolean;
+  keepJSDoc?: boolean;
+  onProgress?: (current: number, total: number) => void;
 };
 
 export type FileCleanReport = {
   file: string;
   removed: number;
   previews: string[];
+  bytesBefore: number;
+  bytesAfter: number;
 };
 
 export type CleanSummary = {
   filesProcessed: number;
   filesChanged: number;
   commentsRemoved: number;
+  bytesBefore: number;
+  bytesAfter: number;
   reports: FileCleanReport[];
 };

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

@@ -34,4 +34,14 @@ export class GitService {
     await load(['ls-files', '--others', '--exclude-standard']);
     return [...changed].sort();
   }
+
+  async getStagedFiles(): Promise<string[]> {
+    await this.ensureRepo();
+    const { stdout } = await execa('git', ['diff', '--name-only', '--staged']);
+    return stdout
+      .split('\n')
+      .map((entry) => entry.trim())
+      .filter((entry) => entry.length > 0)
+      .sort();
+  }
 }