kodu 2.0.2 → 2.1.1

package/package.json

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

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

@@ -7,6 +7,7 @@ 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 { DepsService } from '../../shared/deps/deps.service';
 import { TokenizerService } from '../../shared/tokenizer/tokenizer.service';
 
 type OutputFormat = 'xml' | 'text';
@@ -20,6 +21,9 @@ type PackOptions = {
   list?: boolean;
   format?: OutputFormat;
   clean?: boolean;
+  deps?: boolean;
+  depsDepth?: number;
+  explain?: boolean;
 };
 
 type TemplateContext = {
@@ -41,6 +45,7 @@ export class PackCommand extends CommandRunner {
     private readonly fsService: FsService,
     private readonly tokenizer: TokenizerService,
     private readonly cleaner: CleanerService,
+    private readonly depsService: DepsService,
   ) {
     super();
   }
@@ -98,6 +103,36 @@ export class PackCommand extends CommandRunner {
     return true;
   }
 
+  @Option({
+    flags: '--deps',
+    description:
+      'Trace imports from entry point(s) and include their dependencies',
+  })
+  parseDeps(): boolean {
+    return true;
+  }
+
+  @Option({
+    flags: '--deps-depth <n>',
+    description: 'Max import depth when using --deps (default: unlimited)',
+  })
+  parseDepsDepth(value: string): number {
+    const n = Number.parseInt(value, 10);
+    if (Number.isNaN(n) || n < 1) {
+      this.ui.log.warn(`Invalid --deps-depth "${value}", ignoring`);
+      return Infinity;
+    }
+    return n;
+  }
+
+  @Option({
+    flags: '--explain',
+    description: 'Print why each file was included (requires --deps)',
+  })
+  parseExplain(): boolean {
+    return true;
+  }
+
   @Option({
     flags: '-f, --format <format>',
     description: 'Output format: xml (default) or text',
@@ -110,7 +145,7 @@ export class PackCommand extends CommandRunner {
     return value;
   }
 
-  async run(_inputs: string[], options: PackOptions): Promise<void> {
+  async run(inputs: string[], options: PackOptions): Promise<void> {
     const spinner = this.ui
       .createSpinner({ text: 'Collecting files...' })
       .start();
@@ -118,13 +153,39 @@ 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, ...extraExcludes],
-        contentBasedBinaryDetection: packer.contentBasedBinaryDetection,
-        rootPaths: options.path,
-      });
+
+      let files: string[];
+      let explainMap: Map<string, string> | undefined;
+
+      if (options.deps) {
+        if (inputs.length === 0) {
+          spinner.error('--deps requires at least one entry file as argument');
+          this.ui.log.error('Usage: kodu pack <entry.ts> [more.ts...] --deps');
+          process.exitCode = 1;
+          return;
+        }
+
+        spinner.text = 'Resolving dependency graph...';
+        const result = this.depsService.collectDependencies(
+          inputs,
+          process.cwd(),
+          {
+            maxDepth: options.depsDepth,
+            includeTypes: true,
+            includeDynamic: false,
+          },
+        );
+        files = result.files;
+        explainMap = result.explain;
+      } else {
+        files = await this.fsService.findProjectFiles({
+          excludeBinary: true,
+          useGitignore: packer.useGitignore,
+          ignore: [...packer.ignore, ...extraExcludes],
+          contentBasedBinaryDetection: packer.contentBasedBinaryDetection,
+          rootPaths: inputs.length > 0 ? inputs : options.path,
+        });
+      }
 
       if (files.length === 0) {
         spinner.stop('No files to pack.');
@@ -135,11 +196,28 @@ export class PackCommand extends CommandRunner {
       if (options.list) {
         spinner.success(`Found ${files.length} files`);
         for (const file of files) {
-          this.ui.log.info(file);
+          if (options.explain && explainMap) {
+            const absFile = path.resolve(process.cwd(), file);
+            const reason =
+              explainMap.get(absFile) ?? explainMap.get(file) ?? '';
+            this.ui.log.info(`${file}  ← ${reason}`);
+          } else {
+            this.ui.log.info(file);
+          }
         }
         return;
       }
 
+      if (options.explain && explainMap) {
+        spinner.success(`Found ${files.length} files`);
+        this.ui.log.info('Dependency explanation:');
+        for (const file of files) {
+          const absFile = path.resolve(process.cwd(), file);
+          const reason = explainMap.get(absFile) ?? explainMap.get(file) ?? '';
+          this.ui.log.info(`  ${file}  ← ${reason}`);
+        }
+      }
+
       const format: OutputFormat = options.format ?? 'xml';
       const context = await this.buildContext(files, format, options.clean);
       const fileList = files.join('\n');

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

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

package/src/shared/deps/deps.module.ts

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

package/src/shared/deps/deps.service.ts

@@ -0,0 +1,175 @@
+import path from 'node:path';
+import { Injectable } from '@nestjs/common';
+import { Project } from 'ts-morph';
+
+export type DepsResult = {
+  files: string[];
+  explain: Map<string, string>;
+};
+
+type CollectOptions = {
+  maxDepth?: number;
+  includeTypes?: boolean;
+  includeDynamic?: boolean;
+};
+
+@Injectable()
+export class DepsService {
+  collectDependencies(
+    entryFiles: string[],
+    projectRoot: string,
+    options: CollectOptions = {},
+  ): DepsResult {
+    const {
+      maxDepth = Infinity,
+      includeTypes = true,
+      includeDynamic = false,
+    } = options;
+
+    const tsConfigPath = this.findTsConfig(projectRoot);
+    const project = tsConfigPath
+      ? new Project({
+          tsConfigFilePath: tsConfigPath,
+          skipAddingFilesFromTsConfig: true,
+        })
+      : new Project({
+          compilerOptions: {
+            allowJs: true,
+            resolveJsonModule: true,
+            moduleResolution: 2, // NodeJs
+          },
+        });
+
+    const visited = new Set<string>();
+    const explain = new Map<string, string>();
+
+    const absEntries = entryFiles.map((f) =>
+      path.isAbsolute(f) ? f : path.resolve(projectRoot, f),
+    );
+
+    for (const entry of absEntries) {
+      explain.set(entry, 'entry point');
+      this.collect(
+        project,
+        entry,
+        projectRoot,
+        visited,
+        explain,
+        0,
+        maxDepth,
+        includeTypes,
+        includeDynamic,
+      );
+    }
+
+    const files = [...visited].map((abs) =>
+      path.relative(projectRoot, abs).split(path.sep).join(path.posix.sep),
+    );
+
+    return { files, explain };
+  }
+
+  private collect(
+    project: Project,
+    absFile: string,
+    projectRoot: string,
+    visited: Set<string>,
+    explain: Map<string, string>,
+    depth: number,
+    maxDepth: number,
+    includeTypes: boolean,
+    includeDynamic: boolean,
+  ): void {
+    if (visited.has(absFile)) return;
+    visited.add(absFile);
+
+    if (depth >= maxDepth) return;
+
+    let sourceFile = project.getSourceFile(absFile);
+    if (!sourceFile) {
+      try {
+        sourceFile = project.addSourceFileAtPath(absFile);
+      } catch {
+        return;
+      }
+    }
+
+    const relFrom = path
+      .relative(projectRoot, absFile)
+      .split(path.sep)
+      .join(path.posix.sep);
+
+    for (const importDecl of sourceFile.getImportDeclarations()) {
+      if (!includeTypes && importDecl.isTypeOnly()) continue;
+
+      const resolved = importDecl.getModuleSpecifierSourceFile();
+      if (!resolved) continue;
+
+      const absResolved = resolved.getFilePath();
+      if (absResolved.includes('node_modules')) continue;
+
+      if (!explain.has(absResolved)) {
+        const what = importDecl.isTypeOnly() ? 'type import' : 'import';
+        explain.set(absResolved, `${what} from ${relFrom}`);
+      }
+
+      this.collect(
+        project,
+        absResolved,
+        projectRoot,
+        visited,
+        explain,
+        depth + 1,
+        maxDepth,
+        includeTypes,
+        includeDynamic,
+      );
+    }
+
+    void includeDynamic;
+
+    for (const exportDecl of sourceFile.getExportDeclarations()) {
+      const resolved = exportDecl.getModuleSpecifierSourceFile();
+      if (!resolved) continue;
+
+      const absResolved = resolved.getFilePath();
+      if (absResolved.includes('node_modules')) continue;
+
+      if (!explain.has(absResolved)) {
+        const relFrom2 = path
+          .relative(projectRoot, absFile)
+          .split(path.sep)
+          .join(path.posix.sep);
+        explain.set(absResolved, `re-export from ${relFrom2}`);
+      }
+
+      this.collect(
+        project,
+        absResolved,
+        projectRoot,
+        visited,
+        explain,
+        depth + 1,
+        maxDepth,
+        includeTypes,
+        includeDynamic,
+      );
+    }
+  }
+
+  private findTsConfig(projectRoot: string): string | undefined {
+    const candidates = [
+      path.join(projectRoot, 'tsconfig.json'),
+      path.join(projectRoot, 'tsconfig.base.json'),
+    ];
+    for (const c of candidates) {
+      try {
+        require('node:fs').accessSync(c);
+        return c;
+      } catch {
+        // not found
+      }
+    }
+    return undefined;
+  }
+}