kodu 1.2.0 → 2.0.0

package/src/commands/commit/commit.command.ts

@@ -1,139 +0,0 @@
-import { writeFile } from 'node:fs/promises';
-import { Command, CommandRunner, Option } from 'nest-commander';
-import { UiService } from '../../core/ui/ui.service';
-import { AiService } from '../../shared/ai/ai.service';
-import { GitService } from '../../shared/git/git.service';
-
-type CommitOptions = {
-  ci?: boolean;
-  output?: string;
-};
-
-@Command({
-  name: 'commit',
-  description: 'Generate and apply commit message',
-})
-export class CommitCommand extends CommandRunner {
-  constructor(
-    private readonly ui: UiService,
-    private readonly git: GitService,
-    private readonly ai: AiService,
-  ) {
-    super();
-  }
-
-  @Option({ flags: '--ci', description: 'CI mode: no spinners and dialogs' })
-  parseCi(): boolean {
-    return true;
-  }
-
-  @Option({
-    flags: '-o, --output <path>',
-    description: 'Save message to file',
-  })
-  parseOutput(value: string): string {
-    return value;
-  }
-
-  async run(_inputs: string[], options: CommitOptions = {}): Promise<void> {
-    const ciMode = Boolean(options.ci);
-    const spinner = ciMode
-      ? undefined
-      : this.ui.createSpinner({ text: 'Collecting diff...' }).start();
-
-    const logProgress = (text: string): void => {
-      if (ciMode) {
-        return;
-      }
-      if (spinner) {
-        spinner.text = text;
-        return;
-      }
-      this.ui.log.info(text);
-    };
-
-    const finishProgress = (text: string): void => {
-      if (ciMode) {
-        return;
-      }
-      if (spinner) {
-        spinner.success(text);
-        return;
-      }
-      this.ui.log.success(text);
-    };
-
-    try {
-      if (!this.ai.hasApiKey()) {
-        const envName = this.ai.getApiKeyEnvName();
-        if (spinner) {
-          spinner.stop('AI key not found');
-        } else {
-          this.ui.log.error('AI key not found');
-        }
-        this.ui.log.warn(`'commit' command requires AI key to work.`);
-        this.ui.log.info(`Set key: export ${envName}=<your_key>`);
-        this.ui.log.info(
-          `Environment variable name is configured via llm.apiKeyEnv in kodu.json`,
-        );
-        process.exitCode = 1;
-        return;
-      }
-
-      await this.git.ensureRepo();
-
-      const hasStaged = await this.git.hasStagedChanges();
-      if (!hasStaged) {
-        if (spinner) {
-          spinner.stop('No staged changes');
-        } else {
-          this.ui.log.info('No staged changes');
-        }
-        this.ui.log.warn('First run git add for the required files.');
-        return;
-      }
-
-      const diff = await this.git.getStagedDiff();
-      if (!diff.trim()) {
-        if (spinner) {
-          spinner.stop(
-            'Diff is empty - possibly everything excluded by packer.ignore',
-          );
-        } else {
-          this.ui.log.info(
-            'Diff is empty - possibly everything excluded by packer.ignore',
-          );
-        }
-        this.ui.log.warn(
-          'Diff is empty: all changes fell into packer.ignore exclusions.',
-        );
-        return;
-      }
-
-      logProgress('Generating commit message...');
-      const commitMessage = await this.ai.generateCommitMessage(diff);
-
-      finishProgress('Message ready');
-      if (!ciMode) {
-        this.ui.log.info(`Suggestion: ${commitMessage}`);
-      }
-
-      console.log(commitMessage);
-      if (options.output) {
-        await writeFile(options.output, commitMessage, { encoding: 'utf8' });
-        if (!ciMode) {
-          this.ui.log.success(`Message saved to ${options.output}`);
-        }
-      }
-    } catch (error) {
-      if (spinner) {
-        spinner.error('Error creating commit');
-      } else {
-        this.ui.log.error('Error creating commit');
-      }
-      const message = error instanceof Error ? error.message : 'Unknown error';
-      this.ui.log.error(message);
-      process.exitCode = 1;
-    }
-  }
-}

package/src/commands/commit/commit.module.ts

@@ -1,12 +0,0 @@
-import { Module } from '@nestjs/common';
-import { ConfigModule } from '../../core/config/config.module';
-import { UiModule } from '../../core/ui/ui.module';
-import { AiModule } from '../../shared/ai/ai.module';
-import { GitModule } from '../../shared/git/git.module';
-import { CommitCommand } from './commit.command';
-
-@Module({
-  imports: [ConfigModule, UiModule, GitModule, AiModule],
-  providers: [CommitCommand],
-})
-export class CommitModule {}

package/src/commands/ops/ops.command.ts

@@ -1,30 +0,0 @@
-import { Command, CommandRunner } from 'nest-commander';
-import { printJson } from './ops.utils';
-import { OpsEnvCommand } from './subcommands/ops-env.command';
-import { OpsRoutesCommand } from './subcommands/ops-routes.command';
-import { OpsServiceCommand } from './subcommands/ops-service.command';
-import { OpsSysinfoCommand } from './subcommands/ops-sysinfo.command';
-
-@Command({
-  name: 'ops',
-  description: 'Remote server operations for agents',
-  subCommands: [
-    OpsSysinfoCommand,
-    OpsEnvCommand,
-    OpsRoutesCommand,
-    OpsServiceCommand,
-  ],
-})
-export class OpsCommand extends CommandRunner {
-  async run(): Promise<void> {
-    printJson(
-      {
-        status: 'error',
-        code: 'VALIDATION_ERROR',
-        error: 'Missing ops subcommand',
-      },
-      true,
-    );
-    process.exitCode = 1;
-  }
-}

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

@@ -1,20 +0,0 @@
-import { Module } from '@nestjs/common';
-import { ConfigModule } from '../../core/config/config.module';
-import { SshModule } from '../../shared/ssh/ssh.module';
-import { OpsCommand } from './ops.command';
-import { OpsEnvCommand } from './subcommands/ops-env.command';
-import { OpsRoutesCommand } from './subcommands/ops-routes.command';
-import { OpsServiceCommand } from './subcommands/ops-service.command';
-import { OpsSysinfoCommand } from './subcommands/ops-sysinfo.command';
-
-@Module({
-  imports: [ConfigModule, SshModule],
-  providers: [
-    OpsCommand,
-    OpsSysinfoCommand,
-    OpsEnvCommand,
-    OpsRoutesCommand,
-    OpsServiceCommand,
-  ],
-})
-export class OpsModule {}

package/src/commands/ops/ops.types.ts

@@ -1,24 +0,0 @@
-import type { ServerConfig } from '../../core/config/config.schema';
-
-export type OpsErrorCode =
-  | 'CLI_ERROR'
-  | 'CONFIG_ERROR'
-  | 'NOT_FOUND'
-  | 'VALIDATION_ERROR';
-
-export type ResolvedServerConfig = ServerConfig & {
-  sshKeyPath: string;
-  paths?: {
-    apps: string;
-    caddy?: string;
-  };
-};
-
-export class OpsCliError extends Error {
-  constructor(
-    public readonly code: OpsErrorCode,
-    message: string,
-  ) {
-    super(message);
-  }
-}

package/src/commands/ops/ops.utils.ts

@@ -1,160 +0,0 @@
-import { access } from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import type { KoduConfig, ServerConfig } from '../../core/config/config.schema';
-import type { SshResult } from '../../shared/ssh/ssh.service';
-import {
-  OpsCliError,
-  type OpsErrorCode,
-  type ResolvedServerConfig,
-} from './ops.types';
-
-const DEFAULT_APPS_PATH = '/var/agent-apps';
-
-export function printJson(payload: unknown, isError = false): void {
-  const line = JSON.stringify(payload);
-  if (isError) {
-    console.error(line);
-    return;
-  }
-  console.log(line);
-}
-
-export function printCliError(error: unknown): void {
-  const cliError = toCliError(error);
-  printJson(
-    {
-      status: 'error',
-      code: cliError.code,
-      error: cliError.message,
-    },
-    true,
-  );
-}
-
-export function printSshError(result: SshResult, command: string): void {
-  printJson({
-    status: 'error',
-    code: result.exitCode,
-    stderr: result.stderr || result.error || 'Unknown SSH error',
-    command,
-  });
-}
-
-export async function resolveServerOrThrow(
-  config: KoduConfig,
-  alias: string,
-): Promise<ResolvedServerConfig> {
-  const servers = config.ops?.servers;
-  if (!servers) {
-    throw new OpsCliError(
-      'CONFIG_ERROR',
-      'ops.servers not configured in kodu.json',
-    );
-  }
-
-  const server = servers[alias];
-  if (!server) {
-    throw new OpsCliError(
-      'VALIDATION_ERROR',
-      `Server alias '${alias}' not found in kodu.json`,
-    );
-  }
-
-  const resolved = normalizeServer(server);
-  await assertSshKeyExists(resolved.sshKeyPath);
-  return resolved;
-}
-
-export function resolveAppsPath(server: ResolvedServerConfig): string {
-  return server.paths?.apps ?? DEFAULT_APPS_PATH;
-}
-
-export function resolveCaddyPath(server: ResolvedServerConfig): string {
-  return (
-    server.paths?.caddy ?? path.posix.join(resolveAppsPath(server), 'caddy')
-  );
-}
-
-export function shellQuote(value: string): string {
-  return `'${value.replace(/'/g, `'"'"'`)}'`;
-}
-
-export function ensureEnvKey(key: string | undefined): string {
-  if (!key) {
-    throw new OpsCliError('VALIDATION_ERROR', 'Option --key is required');
-  }
-
-  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
-    throw new OpsCliError(
-      'VALIDATION_ERROR',
-      'Invalid env key format. Allowed: [A-Za-z_][A-Za-z0-9_]*',
-    );
-  }
-
-  return key;
-}
-
-export function ensureRequired(
-  value: string | undefined,
-  name: string,
-): string {
-  if (!value) {
-    throw new OpsCliError('VALIDATION_ERROR', `Option --${name} is required`);
-  }
-  return value;
-}
-
-export function ensureAction<T extends string>(
-  value: string,
-  allowed: readonly T[],
-  context: string,
-): T {
-  if (!allowed.includes(value as T)) {
-    throw new OpsCliError(
-      'VALIDATION_ERROR',
-      `Unsupported ${context}: '${value}'. Allowed: ${allowed.join(', ')}`,
-    );
-  }
-  return value as T;
-}
-
-function normalizeServer(server: ServerConfig): ResolvedServerConfig {
-  const sshKeyPath = server.sshKeyPath.startsWith('~')
-    ? path.join(os.homedir(), server.sshKeyPath.slice(1))
-    : server.sshKeyPath;
-  const apps = server.paths?.apps ?? DEFAULT_APPS_PATH;
-  return {
-    ...server,
-    sshKeyPath: path.isAbsolute(sshKeyPath)
-      ? sshKeyPath
-      : path.resolve(process.cwd(), sshKeyPath),
-    paths: {
-      apps,
-      caddy: server.paths?.caddy,
-    },
-  };
-}
-
-async function assertSshKeyExists(sshKeyPath: string): Promise<void> {
-  try {
-    await access(sshKeyPath);
-  } catch {
-    throw new OpsCliError(
-      'VALIDATION_ERROR',
-      `SSH key file not found or inaccessible: ${sshKeyPath}`,
-    );
-  }
-}
-
-function toCliError(error: unknown): { code: OpsErrorCode; message: string } {
-  if (error instanceof OpsCliError) {
-    return { code: error.code, message: error.message };
-  }
-
-  if (error instanceof Error) {
-    return { code: 'CLI_ERROR', message: error.message };
-  }
-
-  return { code: 'CLI_ERROR', message: 'Unknown CLI error' };
-}

package/src/commands/ops/subcommands/ops-env.command.ts

@@ -1,165 +0,0 @@
-import path from 'node:path';
-import { CommandRunner, Option, SubCommand } from 'nest-commander';
-import { ConfigService } from '../../../core/config/config.service';
-import { SshService } from '../../../shared/ssh/ssh.service';
-import { OpsCliError } from '../ops.types';
-import {
-  ensureAction,
-  ensureEnvKey,
-  ensureRequired,
-  printCliError,
-  printJson,
-  printSshError,
-  resolveAppsPath,
-  resolveServerOrThrow,
-  shellQuote,
-} from '../ops.utils';
-
-type OpsEnvAction = 'get' | 'set' | 'unset';
-
-type OpsEnvOptions = {
-  server?: string;
-  action?: string;
-  project?: string;
-  key?: string;
-  val?: string;
-};
-
-@SubCommand({
-  name: 'env',
-  description:
-    'Manage remote .env files for a specific project.\nExamples:\n  kodu ops env --server dev --action get --project my-app\n  kodu ops env --server dev --action set --project my-app --key PORT --val 3000\n  kodu ops env --server dev --action unset --project my-app --key PORT',
-})
-export class OpsEnvCommand extends CommandRunner {
-  constructor(
-    private readonly configService: ConfigService,
-    private readonly sshService: SshService,
-  ) {
-    super();
-  }
-
-  @Option({
-    flags: '-s, --server <name>',
-    description: 'Server alias defined in kodu.json (e.g., dev)',
-  })
-  parseServer(value: string): string {
-    return value;
-  }
-
-  @Option({
-    flags: '-a, --action <type>',
-    description: 'Action to perform: get | set | unset',
-  })
-  parseAction(value: string): string {
-    return value;
-  }
-
-  @Option({
-    flags: '-p, --project <name>',
-    description: 'Target project directory name',
-  })
-  parseProject(value: string): string {
-    return value;
-  }
-
-  @Option({ flags: '--key <key>', description: 'Environment key' })
-  parseKey(value: string): string {
-    return value;
-  }
-
-  @Option({ flags: '--val <value>', description: 'Environment value' })
-  parseVal(value: string): string {
-    return value;
-  }
-
-  async run(
-    passedParams: string[],
-    options: OpsEnvOptions = {},
-  ): Promise<void> {
-    try {
-      if (passedParams.length > 0) {
-        throw new OpsCliError(
-          'VALIDATION_ERROR',
-          'Positional arguments are not supported. Use named flags (e.g., --server, --action). Run with --help for examples.',
-        );
-      }
-
-      const serverAlias = ensureRequired(options.server, 'server');
-      const rawAction = ensureRequired(options.action, 'action');
-      const project = ensureRequired(options.project, 'project');
-
-      const action = ensureAction<OpsEnvAction>(
-        rawAction,
-        ['get', 'set', 'unset'],
-        'env action',
-      );
-      const server = await resolveServerOrThrow(
-        this.configService.getConfig(),
-        serverAlias,
-      );
-      const envPath = path.posix.join(resolveAppsPath(server), project, '.env');
-
-      const command = this.buildCommand(action, envPath, options);
-      const result = await this.sshService.execute(server, command);
-
-      if (!result.success) {
-        printSshError(result, command);
-        return;
-      }
-
-      if (action === 'get') {
-        printJson({ status: 'ok', data: { content: result.stdout } });
-        return;
-      }
-
-      printJson({ status: 'ok', message: 'Env updated' });
-    } catch (error) {
-      printCliError(error);
-      process.exitCode = 1;
-    }
-  }
-
-  private buildCommand(
-    action: OpsEnvAction,
-    envPath: string,
-    options: OpsEnvOptions,
-  ): string {
-    const quotedPath = shellQuote(envPath);
-
-    if (action === 'get') {
-      return `cat ${quotedPath}`;
-    }
-
-    const key = ensureEnvKey(options.key);
-    const quotedKey = shellQuote(key);
-
-    if (action === 'set') {
-      const val = ensureRequired(options.val, 'val');
-      const quotedVal = shellQuote(val);
-      const scriptLines = [
-        `ENV_FILE=${quotedPath}`,
-        `KEY=${quotedKey}`,
-        `VAL=${quotedVal}`,
-        'mkdir -p "$(dirname "$ENV_FILE")"',
-        'touch "$ENV_FILE"',
-        'awk -v k="$KEY" -v v="$VAL" \'BEGIN{found=0} $0 ~ "^" k "=" { print k "=" v; found=1; next } { print } END { if (!found) print k "=" v }\' "$ENV_FILE" > "$ENV_FILE.tmp"',
-        'mv "$ENV_FILE.tmp" "$ENV_FILE"',
-      ];
-      return this.buildBashScript(scriptLines);
-    }
-
-    const scriptLines = [
-      `ENV_FILE=${quotedPath}`,
-      `KEY=${quotedKey}`,
-      'if [ ! -f "$ENV_FILE" ]; then exit 0; fi',
-      'grep -v "^$KEY=" "$ENV_FILE" > "$ENV_FILE.tmp"',
-      'mv "$ENV_FILE.tmp" "$ENV_FILE"',
-    ];
-    return this.buildBashScript(scriptLines);
-  }
-
-  private buildBashScript(scriptLines: string[]): string {
-    const script = scriptLines.join(' && ');
-    return `bash -lc ${shellQuote(script)}`;
-  }
-}