kodu 2.2.0 → 3.0.2

package/src/commands/ops/ops.module.ts

@@ -1,23 +0,0 @@
-import { Module } from '@nestjs/common';
-import { OpsCommand } from './ops.command';
-import { OpsAddCommand } from './ops-add.command';
-import { OpsInitCommand } from './ops-init.command';
-import { OpsListCommand } from './ops-list.command';
-import { OpsPathCommand } from './ops-path.command';
-import { OpsRunbookCommand } from './ops-runbook.command';
-import { OpsStatusCommand } from './ops-status.command';
-import { OpsUseCommand } from './ops-use.command';
-
-@Module({
-  providers: [
-    OpsCommand,
-    OpsInitCommand,
-    OpsListCommand,
-    OpsAddCommand,
-    OpsStatusCommand,
-    OpsUseCommand,
-    OpsPathCommand,
-    OpsRunbookCommand,
-  ],
-})
-export class OpsModule {}

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

@@ -1,347 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import clipboard from 'clipboardy';
-import { Command, CommandRunner, Option } from 'nest-commander';
-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 { DepsService } from '../../shared/deps/deps.service';
-import { TokenizerService } from '../../shared/tokenizer/tokenizer.service';
-
-type OutputFormat = 'xml' | 'text';
-
-type PackOptions = {
-  copy?: boolean;
-  template?: string;
-  out?: string;
-  path?: string[];
-  exclude?: string[];
-  list?: boolean;
-  format?: OutputFormat;
-  clean?: boolean;
-  deps?: boolean;
-  depsDepth?: number;
-  explain?: boolean;
-};
-
-type TemplateContext = {
-  context: string;
-  fileList: string;
-  tokenCount: number;
-  usdEstimate: number;
-};
-
-@Command({
-  name: 'pack',
-  description: 'Collect project context into a single file',
-})
-export class PackCommand extends CommandRunner {
-  constructor(
-    private readonly ui: UiService,
-    private readonly configService: ConfigService,
-    private readonly promptService: PromptService,
-    private readonly fsService: FsService,
-    private readonly tokenizer: TokenizerService,
-    private readonly cleaner: CleanerService,
-    private readonly depsService: DepsService,
-  ) {
-    super();
-  }
-
-  @Option({ flags: '-c, --copy', description: 'Copy result to clipboard' })
-  parseCopy(): boolean {
-    return true;
-  }
-
-  @Option({
-    flags: '-t, --template <name>',
-    description: 'Template name from .kodu/prompts',
-  })
-  parseTemplate(value: string): string {
-    return value;
-  }
-
-  @Option({
-    flags: '-o, --out <path>',
-    description: 'Path to save result',
-  })
-  parseOut(value: string): string {
-    return value;
-  }
-
-  @Option({
-    flags: '-p, --path <path>',
-    description: 'Directory or glob to include (repeatable)',
-  })
-  parsePath(value: string, previous: string[] = []): string[] {
-    return [...previous, value];
-  }
-
-  @Option({
-    flags: '-e, --exclude <pattern>',
-    description: 'Additional exclude pattern (repeatable)',
-  })
-  parseExclude(value: string, previous: string[] = []): string[] {
-    return [...previous, value];
-  }
-
-  @Option({
-    flags: '-l, --list',
-    description: 'Print file list only, without content',
-  })
-  parseList(): boolean {
-    return true;
-  }
-
-  @Option({
-    flags: '--clean',
-    description: 'Strip comments in-memory before packing (files not modified)',
-  })
-  parseClean(): boolean {
-    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',
-  })
-  parseFormat(value: string): OutputFormat {
-    if (value !== 'xml' && value !== 'text') {
-      this.ui.log.warn(`Unknown format "${value}", using "xml"`);
-      return 'xml';
-    }
-    return value;
-  }
-
-  async run(inputs: string[], options: PackOptions): Promise<void> {
-    const spinner = this.ui
-      .createSpinner({ text: 'Collecting files...' })
-      .start();
-
-    try {
-      const { packer } = this.configService.getConfig();
-      const extraExcludes = options.exclude ?? [];
-
-      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.');
-        this.ui.log.warn('No files to pack.');
-        return;
-      }
-
-      if (options.list) {
-        spinner.success(`Found ${files.length} files`);
-        for (const file of files) {
-          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');
-      const { tokens, usdEstimate } = this.tokenizer.count(context);
-
-      const basePrompt = await this.applyConfiguredPrompt({
-        context,
-        fileList,
-        tokenCount: tokens,
-        usdEstimate,
-      });
-
-      const templateApplied = options.template
-        ? await this.applyTemplate(options.template, {
-            context,
-            fileList,
-            tokenCount: tokens,
-            usdEstimate,
-          })
-        : basePrompt;
-
-      const outputPath = await this.writeOutput(templateApplied, options.out);
-
-      if (options.copy) {
-        await clipboard.write(templateApplied);
-      }
-
-      spinner.success('Collection complete');
-      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}${options.clean ? ' (comments stripped)' : ''}`,
-      );
-      this.ui.log.success(`Saved to ${outputPath}`);
-
-      if (options.copy) {
-        this.ui.log.success('Result copied to clipboard');
-      }
-    } catch (error) {
-      spinner.error('Error collecting context');
-      const message = error instanceof Error ? error.message : 'Unknown error';
-      this.ui.log.error(message);
-      process.exitCode = 1;
-    }
-  }
-
-  private async buildContext(
-    files: string[],
-    format: OutputFormat,
-    clean = false,
-  ): Promise<string> {
-    const chunks = await Promise.all(
-      files.map(async (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>`;
-        }
-        return `// file: ${file}\n${content}`;
-      }),
-    );
-
-    if (format === 'xml') {
-      return `<files>\n${chunks.join('\n\n')}\n</files>`;
-    }
-    return chunks.join('\n\n');
-  }
-
-  private async applyTemplate(
-    name: string,
-    ctx: TemplateContext,
-  ): Promise<string> {
-    const template = await this.loadTemplate(name);
-    return this.fillTemplate(template, ctx);
-  }
-
-  private async loadTemplate(name: string): Promise<string> {
-    return this.promptService.loadFromPromptsDir(name);
-  }
-
-  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 applyConfiguredPrompt(ctx: TemplateContext): Promise<string> {
-    const config = this.configService.getConfig();
-    const packPrompt = config.prompts?.pack;
-
-    if (!packPrompt) {
-      return ctx.context;
-    }
-
-    try {
-      const template = await this.promptService.load(packPrompt);
-      return this.fillTemplate(template, ctx);
-    } catch {
-      this.ui.log.warn(
-        `Prompt file not found: ${packPrompt}, using raw context`,
-      );
-      return ctx.context;
-    }
-  }
-
-  private fillTemplate(template: string, ctx: TemplateContext): string {
-    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;
-  }
-}

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

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

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

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

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

@@ -1,58 +0,0 @@
-import { z } from 'zod';
-
-const cleanerSchema = z.object({
-  whitelist: z.array(z.string()).default(['//!']),
-  keepJSDoc: z.boolean().default(true),
-  useGitignore: z.boolean().default(true),
-  ignore: z.array(z.string()).default([]),
-});
-
-const packerSchema = z.object({
-  ignore: z
-    .array(z.string())
-    .default([
-      'package-lock.json',
-      'yarn.lock',
-      'pnpm-lock.yaml',
-      '.git',
-      '.kodu',
-      'node_modules',
-      'dist',
-      'coverage',
-    ]),
-  useGitignore: z.boolean().default(true),
-  contentBasedBinaryDetection: z.boolean().default(false),
-});
-
-const promptsSchema = z
-  .object({
-    pack: z.string().optional(),
-  })
-  .optional();
-
-export const configSchema = z.object({
-  $schema: z.string().optional(),
-  cleaner: cleanerSchema.default({
-    whitelist: ['//!'],
-    keepJSDoc: true,
-    useGitignore: true,
-    ignore: [],
-  }),
-  packer: packerSchema.default({
-    ignore: [
-      'package-lock.json',
-      'yarn.lock',
-      'pnpm-lock.yaml',
-      '.git',
-      '.kodu',
-      'node_modules',
-      'dist',
-      'coverage',
-    ],
-    useGitignore: true,
-    contentBasedBinaryDetection: false,
-  }),
-  prompts: promptsSchema,
-});
-
-export type KoduConfig = z.infer<typeof configSchema>;

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

@@ -1,43 +0,0 @@
-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());
-
-    const rawConfig =
-      result && !result.isEmpty && result.config ? result.config : {};
-
-    const parsed = configSchema.safeParse(rawConfig);
-
-    if (!parsed.success) {
-      console.error(pc.red('kodu.json is invalid:'));
-      parsed.error.issues.forEach((issue) => {
-        const path = issue.path.join('.') || '(root)';
-        console.error(pc.red(`- ${path}: ${issue.message}`));
-      });
-      this.terminate('Fix the config and run the command again.');
-    }
-
-    return parsed.data;
-  }
-
-  private terminate(message: string): never {
-    console.error(pc.red(message));
-    process.exit(1);
-  }
-}

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

@@ -1,80 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { Injectable } from '@nestjs/common';
-
-@Injectable()
-export class PromptService {
-  private readonly cache = new Map<string, string>();
-
-  async load(source: string): Promise<string> {
-    return this.readSource(source);
-  }
-
-  async loadFromPromptsDir(name: string): Promise<string> {
-    const candidates = this.buildCandidates(name);
-
-    for (const candidate of candidates) {
-      if (await this.exists(candidate)) {
-        return this.readAndCache(candidate);
-      }
-    }
-
-    throw new Error(
-      `Template ${name} not found. Expected files: ${candidates
-        .map((c) => path.relative(process.cwd(), c))
-        .join(', ')}`,
-    );
-  }
-
-  private async readSource(source: string): Promise<string> {
-    const resolved = path.isAbsolute(source)
-      ? source
-      : path.resolve(process.cwd(), source);
-
-    if (await this.exists(resolved)) {
-      return this.readAndCache(resolved);
-    }
-
-    if (this.looksLikeInline(source)) {
-      return source;
-    }
-
-    throw new Error(
-      `Prompt file not found: ${path.relative(process.cwd(), resolved)}`,
-    );
-  }
-
-  private async readAndCache(target: string): Promise<string> {
-    const cached = this.cache.get(target);
-    if (cached) {
-      return cached;
-    }
-    const content = await fs.readFile(target, 'utf8');
-    this.cache.set(target, content);
-    return content;
-  }
-
-  private looksLikeInline(value: string): boolean {
-    if (value.includes('\n')) {
-      return true;
-    }
-    const hasPathSegments = value.includes('/') || value.includes('\\');
-    const hasExtension = path.extname(value) !== '';
-    return value.trim().length > 0 && !hasPathSegments && !hasExtension;
-  }
-
-  private buildCandidates(name: string): string[] {
-    const names = path.extname(name) ? [name] : [`${name}.md`, `${name}.txt`];
-    const root = path.join(process.cwd(), '.kodu', 'prompts');
-    return names.map((variant) => path.join(root, variant));
-  }
-
-  private async exists(target: string): Promise<boolean> {
-    try {
-      await fs.access(target);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}

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

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