gyrus 0.1.0

package/src/commands/adr.ts

@@ -0,0 +1,482 @@
+/**
+ * ADR CLI Command
+ * Handles all ADR-related CLI operations
+ *
+ * Usage:
+ *   gyrus adr list [--workspace <name>] [--status <status>] [--type <type>] [--tags <t1,t2>]
+ *   gyrus adr read <name> [--workspace <name>]
+ *   gyrus adr search <query> [--workspace <name>] [--status <status>] [--type <type>] [--tags <t1,t2>]
+ *   gyrus adr create --title <title> --type <type> --working-folder <path> [options]
+ *   gyrus adr update <name> [--title <title>] [--status <status>] [--content <content>]
+ *
+ * Aliases: gyrus a
+ */
+
+import { readConfig } from '../config/index.ts';
+import { WorkspaceManager } from '../services/workspace.ts';
+import {
+  listAdrs,
+  readAdr,
+  searchAdrs,
+  createAdr,
+  updateAdr,
+} from '../operations/adr.ts';
+import {
+  formatAdrListCli,
+  formatAdrReadCli,
+  formatAdrSearchCli,
+  formatAdrCreateCli,
+  formatAdrUpdateCli,
+} from '../formatters/adr.ts';
+import type { AdrStatus, AdrType } from '../types/index.ts';
+
+const HELP = `
+Usage: gyrus adr <subcommand> [options]
+
+Subcommands:
+  list                     List all ADRs
+  read <name>              Read a specific ADR by name (partial match supported)
+  search <query>           Search ADRs by text query
+  create                   Create a new ADR
+  update <name>            Update an existing ADR
+
+Global Options:
+  -w, --workspace <name>   Target workspace (default: active workspace)
+  -h, --help               Show this help message
+
+List Options:
+  -s, --status <status>    Filter by status (todo, in-progress, in-review, blocked, completed, deprecated)
+  --type <type>            Filter by type (enhancement, debug, research)
+  -t, --tags <t1,t2,...>   Filter by tags (comma-separated)
+
+Search Options:
+  -s, --status <status>    Filter by status
+  --type <type>            Filter by type
+  -t, --tags <t1,t2,...>   Filter by tags
+
+Create Options:
+  --title <title>          ADR title (required)
+  --type <type>            ADR type: enhancement, debug, research (required)
+  --working-folder <path>  Working folder path (required)
+  --description <desc>     Brief description
+  -t, --tags <t1,t2,...>   Tags (comma-separated)
+  -s, --status <status>    Initial status (default: todo)
+  --content <content>      Custom content (or use --file)
+  --file <path>            Read content from file
+
+Update Options:
+  --title <title>          New title
+  --description <desc>     New description
+  -s, --status <status>    New status
+  --type <type>            New type
+  -t, --tags <t1,t2,...>   New tags (replaces existing)
+  --content <content>      New content (or use --file)
+  --file <path>            Read content from file
+  --working-folder <path>  New working folder
+
+Examples:
+  gyrus adr list
+  gyrus adr list --status in-progress
+  gyrus adr read brain-cli
+  gyrus adr search "authentication" --type enhancement
+  gyrus adr create --title "New Feature" --type enhancement --working-folder /path/to/project
+  gyrus adr update brain-cli --status completed
+  gyrus a list -w work
+
+Aliases: a
+`;
+
+/**
+ * Parse command-line arguments into options object
+ */
+function parseArgs(args: string[]): {
+  subcommand: string;
+  positional: string[];
+  options: Record<string, string | boolean>;
+} {
+  const options: Record<string, string | boolean> = {};
+  const positional: string[] = [];
+  let subcommand = '';
+
+  let i = 0;
+
+  // First non-flag argument is the subcommand
+  while (i < args.length && !subcommand) {
+    if (!args[i].startsWith('-')) {
+      subcommand = args[i];
+      i++;
+      break;
+    }
+    i++;
+  }
+
+  // Parse remaining arguments
+  while (i < args.length) {
+    const arg = args[i];
+
+    if (arg === '-h' || arg === '--help') {
+      options.help = true;
+      i++;
+    } else if (arg === '-w' || arg === '--workspace') {
+      options.workspace = args[++i] || '';
+      i++;
+    } else if (arg === '-s' || arg === '--status') {
+      options.status = args[++i] || '';
+      i++;
+    } else if (arg === '--type') {
+      options.type = args[++i] || '';
+      i++;
+    } else if (arg === '-t' || arg === '--tags') {
+      options.tags = args[++i] || '';
+      i++;
+    } else if (arg === '--title') {
+      options.title = args[++i] || '';
+      i++;
+    } else if (arg === '--description') {
+      options.description = args[++i] || '';
+      i++;
+    } else if (arg === '--content') {
+      options.content = args[++i] || '';
+      i++;
+    } else if (arg === '--file') {
+      options.file = args[++i] || '';
+      i++;
+    } else if (arg === '--working-folder') {
+      options.workingFolder = args[++i] || '';
+      i++;
+    } else if (!arg.startsWith('-')) {
+      positional.push(arg);
+      i++;
+    } else {
+      // Unknown flag, skip
+      i++;
+    }
+  }
+
+  return { subcommand, positional, options };
+}
+
+/**
+ * Parse comma-separated string into array
+ */
+function parseList(value: string | undefined): string[] | undefined {
+  if (!value || typeof value !== 'string') return undefined;
+  return value
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+/**
+ * Read content from file if --file option is provided
+ */
+async function getContent(
+  options: Record<string, string | boolean>
+): Promise<string | undefined> {
+  if (options.file && typeof options.file === 'string') {
+    try {
+      const file = Bun.file(options.file);
+      return await file.text();
+    } catch (error) {
+      console.error(`Error reading file: ${options.file}`);
+      process.exit(1);
+    }
+  }
+  return typeof options.content === 'string' ? options.content : undefined;
+}
+
+/**
+ * Validate status value
+ */
+function validateStatus(status: string | undefined): AdrStatus | undefined {
+  if (!status) return undefined;
+  const valid: AdrStatus[] = [
+    'todo',
+    'in-progress',
+    'in-review',
+    'blocked',
+    'completed',
+    'deprecated',
+  ];
+  if (!valid.includes(status as AdrStatus)) {
+    console.error(`Error: Invalid status "${status}"`);
+    console.error(`Valid statuses: ${valid.join(', ')}`);
+    process.exit(1);
+  }
+  return status as AdrStatus;
+}
+
+/**
+ * Validate type value
+ */
+function validateType(type: string | undefined): AdrType | undefined {
+  if (!type) return undefined;
+  const valid: AdrType[] = ['enhancement', 'debug', 'research'];
+  if (!valid.includes(type as AdrType)) {
+    console.error(`Error: Invalid type "${type}"`);
+    console.error(`Valid types: ${valid.join(', ')}`);
+    process.exit(1);
+  }
+  return type as AdrType;
+}
+
+/**
+ * Handle the list subcommand
+ */
+async function handleList(
+  manager: WorkspaceManager,
+  options: Record<string, string | boolean>
+): Promise<void> {
+  const result = await listAdrs(manager, {
+    workspace:
+      typeof options.workspace === 'string' ? options.workspace : undefined,
+    status: validateStatus(options.status as string),
+    type: validateType(options.type as string),
+    tags: parseList(options.tags as string),
+  });
+
+  if (!result.success) {
+    console.error(`Error: ${result.error}`);
+    process.exit(1);
+  }
+
+  console.log(formatAdrListCli(result.data!));
+}
+
+/**
+ * Handle the read subcommand
+ */
+async function handleRead(
+  manager: WorkspaceManager,
+  positional: string[],
+  options: Record<string, string | boolean>
+): Promise<void> {
+  const name = positional[0];
+
+  if (!name) {
+    console.error('Error: Please provide an ADR name');
+    console.error('Usage: gyrus adr read <name>');
+    console.error('\nTip: You can use a partial name to search.');
+    process.exit(1);
+  }
+
+  const result = await readAdr(manager, {
+    workspace:
+      typeof options.workspace === 'string' ? options.workspace : undefined,
+    name,
+  });
+
+  if (!result.success) {
+    console.error(`Error: ${result.error}`);
+    process.exit(1);
+  }
+
+  console.log(formatAdrReadCli(result.data!));
+}
+
+/**
+ * Handle the search subcommand
+ */
+async function handleSearch(
+  manager: WorkspaceManager,
+  positional: string[],
+  options: Record<string, string | boolean>
+): Promise<void> {
+  const query = positional[0];
+  const status = validateStatus(options.status as string);
+  const type = validateType(options.type as string);
+  const tags = parseList(options.tags as string);
+
+  if (!query && !status && !type && !tags?.length) {
+    console.error(
+      'Error: Please provide a search query, status, type, or tags'
+    );
+    console.error(
+      'Usage: gyrus adr search <query> [--status <status>] [--type <type>] [--tags <t1,t2>]'
+    );
+    process.exit(1);
+  }
+
+  const result = await searchAdrs(manager, {
+    workspace:
+      typeof options.workspace === 'string' ? options.workspace : undefined,
+    query,
+    status,
+    type,
+    tags,
+  });
+
+  if (!result.success) {
+    console.error(`Error: ${result.error}`);
+    process.exit(1);
+  }
+
+  console.log(formatAdrSearchCli(result.data!));
+}
+
+/**
+ * Handle the create subcommand
+ */
+async function handleCreate(
+  manager: WorkspaceManager,
+  options: Record<string, string | boolean>
+): Promise<void> {
+  const title = typeof options.title === 'string' ? options.title : undefined;
+  const type = typeof options.type === 'string' ? options.type : undefined;
+  const workingFolder =
+    typeof options.workingFolder === 'string'
+      ? options.workingFolder
+      : undefined;
+  const content = await getContent(options);
+
+  if (!title || !type || !workingFolder) {
+    console.error('Error: Missing required options for create');
+    console.error('Required: --title, --type, --working-folder');
+    console.error('\nExample:');
+    console.error(
+      '  gyrus adr create --title "New Feature" --type enhancement --working-folder /path/to/project'
+    );
+    process.exit(1);
+  }
+
+  const validatedType = validateType(type);
+  if (!validatedType) {
+    process.exit(1);
+  }
+
+  const result = await createAdr(manager, {
+    workspace:
+      typeof options.workspace === 'string' ? options.workspace : undefined,
+    title,
+    type: validatedType,
+    workingFolder,
+    description:
+      typeof options.description === 'string' ? options.description : undefined,
+    tags: parseList(options.tags as string),
+    status: validateStatus(options.status as string),
+    content,
+  });
+
+  if (!result.success) {
+    console.error(`Error: ${result.error}`);
+    process.exit(1);
+  }
+
+  console.log(formatAdrCreateCli(result.data!));
+}
+
+/**
+ * Handle the update subcommand
+ */
+async function handleUpdate(
+  manager: WorkspaceManager,
+  positional: string[],
+  options: Record<string, string | boolean>
+): Promise<void> {
+  const name = positional[0];
+
+  if (!name) {
+    console.error('Error: Please provide an ADR name to update');
+    console.error('Usage: gyrus adr update <name> [options]');
+    process.exit(1);
+  }
+
+  const content = await getContent(options);
+  const hasUpdates =
+    options.title ||
+    options.description ||
+    options.status ||
+    options.type ||
+    options.tags ||
+    content ||
+    options.workingFolder;
+
+  if (!hasUpdates) {
+    console.error('Error: No update options provided');
+    console.error(
+      'Available options: --title, --description, --status, --type, --tags, --content, --file, --working-folder'
+    );
+    process.exit(1);
+  }
+
+  const result = await updateAdr(manager, {
+    workspace:
+      typeof options.workspace === 'string' ? options.workspace : undefined,
+    name,
+    title: typeof options.title === 'string' ? options.title : undefined,
+    description:
+      typeof options.description === 'string' ? options.description : undefined,
+    status: validateStatus(options.status as string),
+    type: validateType(options.type as string),
+    tags: parseList(options.tags as string),
+    content,
+    workingFolder:
+      typeof options.workingFolder === 'string'
+        ? options.workingFolder
+        : undefined,
+  });
+
+  if (!result.success) {
+    console.error(`Error: ${result.error}`);
+    process.exit(1);
+  }
+
+  console.log(formatAdrUpdateCli(result.data!));
+}
+
+/**
+ * Main ADR command handler
+ */
+export async function adrCommand(args: string[]): Promise<void> {
+  const { subcommand, positional, options } = parseArgs(args);
+
+  // Show help if requested or no subcommand
+  if (options.help || !subcommand) {
+    console.log(HELP);
+    process.exit(0);
+  }
+
+  // Load config and create workspace manager
+  const config = readConfig();
+  if (!config) {
+    console.error('Error: No configuration found. Run `gyrus init` first.');
+    process.exit(1);
+  }
+
+  const manager = new WorkspaceManager(config);
+
+  // Route to subcommand handler
+  switch (subcommand) {
+    case 'list':
+    case 'ls':
+      await handleList(manager, options);
+      break;
+
+    case 'read':
+    case 'get':
+    case 'show':
+      await handleRead(manager, positional, options);
+      break;
+
+    case 'search':
+    case 'find':
+      await handleSearch(manager, positional, options);
+      break;
+
+    case 'create':
+    case 'new':
+    case 'add':
+      await handleCreate(manager, options);
+      break;
+
+    case 'update':
+    case 'edit':
+      await handleUpdate(manager, positional, options);
+      break;
+
+    default:
+      console.error(`Unknown subcommand: ${subcommand}`);
+      console.log('\nRun `gyrus adr --help` for usage information.');
+      process.exit(1);
+  }
+}