work-agent 0.1.0

package/components.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "default",
+  "rsc": true,
+  "tsx": true,
+  "tailwind": {
+    "config": "tailwind.config.js",
+    "css": "app/globals.css",
+    "baseColor": "slate",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "iconLibrary": "lucide",
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  },
+  "registries": {
+    "@ai-elements": "https://ai-sdk.dev/elements/api/registry/{name}.json"
+  }
+}

package/lib/command-parser.ts

@@ -0,0 +1,331 @@
+/**
+ * Command Parser
+ * 
+ * Parses commands to extract:
+ * - Command type (kubectl, docker, bash, etc.)
+ * - Verb/action
+ * - Resources
+ * - Options
+ */
+
+export type CommandType = 'kubectl' | 'docker' | 'git' | 'npm' | 'bash' | 'unknown';
+
+export interface ParsedCommand {
+  raw: string;
+  type: CommandType;
+  verb?: string;
+  subverb?: string;
+  resources: string[];
+  namespace?: string;
+  options: Record<string, string>;
+  target?: string;
+  commandString: string;
+}
+
+export function parseCommand(command: string): ParsedCommand {
+  const trimmed = command.trim();
+  const tokens = tokenize(trimmed);
+  
+  if (tokens.length === 0) {
+    return createEmptyParsedCommand(trimmed);
+  }
+  
+  const commandType = detectCommandType(tokens[0]);
+  
+  switch (commandType) {
+    case 'kubectl':
+      return parseKubectlCommand(tokens, trimmed);
+    case 'docker':
+      return parseDockerCommand(tokens, trimmed);
+    case 'git':
+      return parseGitCommand(tokens, trimmed);
+    default:
+      return parseBashCommand(tokens, trimmed);
+  }
+}
+
+function tokenize(command: string): string[] {
+  const tokens: string[] = [];
+  let current = '';
+  let inQuote = false;
+  let quoteChar = '';
+  
+  for (let i = 0; i < command.length; i++) {
+    const char = command[i];
+    
+    if ((char === '"' || char === "'") && !inQuote) {
+      inQuote = true;
+      quoteChar = char;
+      continue;
+    }
+    
+    if (char === quoteChar && inQuote) {
+      inQuote = false;
+      quoteChar = '';
+      continue;
+    }
+    
+    if (!inQuote && char === ' ') {
+      if (current) {
+        tokens.push(current);
+        current = '';
+      }
+    } else {
+      current += char;
+    }
+  }
+  
+  if (current) {
+    tokens.push(current);
+  }
+  
+  return tokens;
+}
+
+function detectCommandType(cmd: string): CommandType {
+  const lower = cmd.toLowerCase();
+  
+  if (lower === 'kubectl' || lower === 'k') return 'kubectl';
+  if (lower === 'docker') return 'docker';
+  if (lower === 'git') return 'git';
+  if (lower === 'npm') return 'npm';
+  if (lower === 'bash' || lower === 'sh' || lower === 'zsh') return 'bash';
+  
+  return 'unknown';
+}
+
+function parseKubectlCommand(tokens: string[], raw: string): ParsedCommand {
+  const result: ParsedCommand = {
+    raw,
+    type: 'kubectl',
+    resources: [],
+    options: {},
+    commandString: raw,
+  };
+  
+  let i = 0;
+  
+  // Skip 'kubectl'
+  if (tokens[i]?.toLowerCase() === 'kubectl' || tokens[i] === 'k') {
+    i++;
+  }
+  
+  if (i >= tokens.length) {
+    return result;
+  }
+  
+  // Get verb
+  result.verb = tokens[i].toLowerCase();
+  i++;
+  
+  // Get subverb (like 'rollout restart')
+  if (i < tokens.length && tokens[i] !== '-' && !tokens[i].startsWith('--')) {
+    result.subverb = tokens[i].toLowerCase();
+    i++;
+  }
+  
+  // Parse remaining tokens
+  while (i < tokens.length) {
+    const token = tokens[i];
+    
+    if (token.startsWith('--')) {
+      // Long option
+      const [key, ...valueParts] = token.slice(2).split('=');
+      result.options[key] = valueParts.join('=') || 'true';
+    } else if (token.startsWith('-') && token.length > 1) {
+      // Short option
+      const key = token[1];
+      result.options[key] = 'true';
+    } else if (!token.startsWith('-')) {
+      // Resource or target
+      const resourceMatch = token.match(/^([a-zA-Z]+)\/([a-zA-Z0-9-]+)$/);
+      
+      if (resourceMatch) {
+        result.resources.push(resourceMatch[1]);
+        result.target = resourceMatch[2];
+      } else if (result.verb === 'delete' || result.verb === 'describe' || result.verb === 'get') {
+        result.resources.push(token);
+        if (!result.target && !token.includes('/')) {
+          result.target = token;
+        }
+      } else if (!result.target) {
+        result.target = token;
+      }
+    }
+    
+    i++;
+  }
+  
+  // Extract namespace from options
+  if (result.options['n'] || result.options['namespace']) {
+    result.namespace = result.options['n'] || result.options['namespace'];
+  }
+  
+  // Build readable command string
+  result.commandString = buildCommandString(result);
+  
+  return result;
+}
+
+function parseDockerCommand(tokens: string[], raw: string): ParsedCommand {
+  const result: ParsedCommand = {
+    raw,
+    type: 'docker',
+    resources: [],
+    options: {},
+    commandString: raw,
+  };
+  
+  let i = 0;
+  
+  // Skip 'docker'
+  if (tokens[i]?.toLowerCase() === 'docker') {
+    i++;
+  }
+  
+  if (i >= tokens.length) {
+    return result;
+  }
+  
+  // Get verb
+  result.verb = tokens[i].toLowerCase();
+  i++;
+  
+  // Parse remaining tokens
+  while (i < tokens.length) {
+    const token = tokens[i];
+    
+    if (token.startsWith('--')) {
+      const [key, ...valueParts] = token.slice(2).split('=');
+      result.options[key] = valueParts.join('=') || 'true';
+    } else if (token.startsWith('-') && token.length > 1) {
+      const key = token[1];
+      result.options[key] = 'true';
+    } else if (!token.startsWith('-')) {
+      if (!result.target) {
+        result.target = token;
+      }
+      result.resources.push(token);
+    }
+    
+    i++;
+  }
+  
+  result.commandString = buildCommandString(result);
+  
+  return result;
+}
+
+function parseGitCommand(tokens: string[], raw: string): ParsedCommand {
+  const result: ParsedCommand = {
+    raw,
+    type: 'git',
+    resources: [],
+    options: {},
+    commandString: raw,
+  };
+  
+  let i = 0;
+  
+  if (tokens[i]?.toLowerCase() === 'git') {
+    i++;
+  }
+  
+  if (i >= tokens.length) {
+    return result;
+  }
+  
+  result.verb = tokens[i].toLowerCase();
+  i++;
+  
+  if (i < tokens.length) {
+    result.target = tokens[i];
+  }
+  
+  result.commandString = buildCommandString(result);
+  
+  return result;
+}
+
+function parseBashCommand(tokens: string[], raw: string): ParsedCommand {
+  const result: ParsedCommand = {
+    raw,
+    type: 'bash',
+    options: {},
+    resources: [],
+    commandString: raw,
+  };
+  
+  if (tokens.length > 0) {
+    result.verb = tokens[0].toLowerCase();
+    result.target = tokens.slice(1).join(' ');
+  }
+  
+  return result;
+}
+
+function createEmptyParsedCommand(raw: string): ParsedCommand {
+  return {
+    raw,
+    type: 'unknown',
+    resources: [],
+    options: {},
+    commandString: raw,
+  };
+}
+
+function buildCommandString(parsed: ParsedCommand): string {
+  const parts: string[] = [parsed.type];
+  
+  if (parsed.verb) {
+    parts.push(parsed.verb);
+  }
+  
+  if (parsed.subverb) {
+    parts.push(parsed.subverb);
+  }
+  
+  if (parsed.target) {
+    parts.push(parsed.target);
+  }
+  
+  return parts.join(' ');
+}
+
+export function extractAffectedResources(command: ParsedCommand): string[] {
+  const resources: string[] = [];
+  
+  if (command.type === 'kubectl') {
+    const verb = command.verb;
+    
+    if (verb === 'delete' || verb === 'describe' || verb === 'get' || verb === 'edit') {
+      resources.push(...command.resources);
+    }
+    
+    if (command.namespace) {
+      resources.push(`namespace/${command.namespace}`);
+    }
+    
+    // Add resource type based on verb
+    const resourceMap: Record<string, string> = {
+      'pod': 'pods',
+      'deployment': 'deployments',
+      'service': 'services',
+      'configmap': 'configmaps',
+      'secret': 'secrets',
+      'statefulset': 'statefulsets',
+      'daemonset': 'daemonsets',
+      'ingress': 'ingresses',
+      'node': 'nodes',
+      'namespace': 'namespaces',
+    };
+    
+    for (const [singular, plural] of Object.entries(resourceMap)) {
+      if (command.raw.includes(singular)) {
+        resources.push(plural);
+      }
+    }
+  }
+  
+  return [...new Set(resources)];
+}