kodu 1.2.0 → 2.0.1

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.1",
   "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/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;
   }
 }