@openweave/weave-cli 1.0.2

package/src/cli.ts

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+
+import { CLIArgs, CommandResult, CliCommand } from './types';
+import { initCommand } from './commands/init';
+import { statusCommand } from './commands/status';
+import { milestonesCommand } from './commands/milestones';
+import { queryCommand } from './commands/query';
+import { orphansCommand } from './commands/orphans';
+import { errorsCommand } from './commands/errors';
+import { saveNodeCommand } from './commands/save-node';
+import { migrateCommand } from './commands/migrate';
+import { skillsCommand } from './commands/skills';
+import { toolsCommand } from './commands/tools';
+
+/**
+ * Weave CLI - Main Entry Point
+ */
+
+const commands: Record<string, CliCommand> = {
+  init: initCommand,
+  status: statusCommand,
+  milestones: milestonesCommand,
+  query: queryCommand,
+  orphans: orphansCommand,
+  errors: errorsCommand,
+  'save-node': saveNodeCommand,
+  migrate: migrateCommand,
+  skills: skillsCommand,
+  tools: toolsCommand,
+};
+
+function parseArgs(): CLIArgs {
+  const argv = process.argv.slice(2);
+
+  if (argv.length === 0) {
+    showHelp();
+    process.exit(0);
+  }
+
+  const command = argv[0];
+  const args: string[] = [];
+  const flags: Record<string, string | boolean> = {};
+
+  for (let i = 1; i < argv.length; i++) {
+    const arg = argv[i];
+
+    if (arg.startsWith('--')) {
+      const parts = arg.substring(2).split('=');
+      const flagName = parts[0];
+      const flagValue = parts[1] !== undefined ? parts[1] : true;
+      flags[flagName] = flagValue;
+    } else if (arg.startsWith('-') && arg.length === 2) {
+      const flagName = arg.substring(1);
+      const nextArg = argv[i + 1];
+      if (nextArg && !nextArg.startsWith('-')) {
+        flags[flagName] = nextArg;
+        i++;
+      } else {
+        flags[flagName] = true;
+      }
+    } else {
+      args.push(arg);
+    }
+  }
+
+  return { command, args, flags };
+}
+
+function showHelp(): void {
+  console.log(`
+🧵 Weave CLI - AI Agent Knowledge Management
+
+Usage: weave <command> [options]
+
+Commands:
+  init <project>        Initialize a new Weave project
+  status                Show current project status
+  milestones            List all milestones and tasks
+  query <term>          Search the knowledge graph
+  orphans               Analyze code for unused exports
+  errors                Show error registry
+  save-node             Manually add a node to the graph
+  skills                Manage skill modules (list, enable, disable, info)
+  tools                 Manage external tool adapters (add, remove, list, info, test)
+  migrate               Migrate data between storage providers
+
+Global Options:
+  --help, -h            Show this help message
+  --version, -v         Show version number
+  --verbose             Enable verbose output
+  --json                Output as JSON
+
+Examples:
+  weave init my-project
+  weave status --verbose
+  weave query "authentication"
+  weave orphans --severity=critical
+  weave save-node --label=MyClass --type=class
+
+For command-specific help:
+  weave <command> --help
+
+Documentation: https://github.com/openweave/openweave
+`);
+}
+
+function showVersion(): void {
+  console.log('Weave CLI v1.0.0');
+}
+
+async function main(): Promise<void> {
+  try {
+    const parsedArgs = parseArgs();
+
+    // Handle global flags
+    if (parsedArgs.flags.help || parsedArgs.flags.h) {
+      showHelp();
+      process.exit(0);
+    }
+
+    if (parsedArgs.flags.version || parsedArgs.flags.v) {
+      showVersion();
+      process.exit(0);
+    }
+
+    const command = commands[parsedArgs.command];
+
+    if (!command) {
+      console.error(
+        `❌ Unknown command: ${parsedArgs.command}\n`
+      );
+      console.log('Run "weave --help" for usage information.');
+      process.exit(1);
+    }
+
+    const result: CommandResult = await command.execute(parsedArgs);
+
+    console.log(result.message);
+
+    if (!result.success) {
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(
+      '❌ CLI Error:',
+      error instanceof Error ? error.message : String(error)
+    );
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/src/commands/errors.ts

@@ -0,0 +1,211 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { CLIArgs, CommandResult, CliCommand } from '../types';
+import { resolveProjectRoot } from '../utils';
+
+interface ErrorEntry {
+  id: string;
+  error_type: string;
+  message: string;
+  file: string;
+  line: number;
+  timestamp: string;
+  severity: 'error' | 'warning' | 'info';
+  suppressed: boolean;
+  correction?: string;
+}
+
+/**
+ * Errors Command - View error registry
+ */
+export class ErrorsCommand implements CliCommand {
+  name = 'errors';
+  description = 'Show error registry and suppression status';
+  usage = 'weave errors [--type=all] [--filter=active]';
+  flags = {
+    type: {
+      short: 't',
+      description:
+        'Filter by error type: all, runtime, syntax, type, semantic',
+      default: 'all',
+    },
+    filter: {
+      short: 'f',
+      description: 'Filter: all, active, suppressed (default: all)',
+      default: 'all',
+    },
+    json: {
+      short: 'j',
+      description: 'Output as JSON',
+      default: false,
+    },
+  };
+
+  async execute(args: CLIArgs): Promise<CommandResult> {
+    try {
+      const projectRoot = resolveProjectRoot();
+      const weaveDir = join(projectRoot, '.weave');
+
+      if (!existsSync(weaveDir)) {
+        return {
+          success: false,
+          message: 'Error: .weave directory not found',
+          error: 'Please run "weave init <project-name>" first',
+        };
+      }
+
+      // Mock error registry
+      const mockErrors: ErrorEntry[] = [
+        {
+          id: 'e1',
+          error_type: 'runtime',
+          message: 'Null pointer exception in data processing',
+          file: 'src/processors/data.ts',
+          line: 142,
+          timestamp: new Date(Date.now() - 2 * 60 * 60 * 1000)
+            .toISOString(),
+          severity: 'error',
+          suppressed: false,
+          correction:
+            'Added null check before accessing property. Fixed in commit abc123.',
+        },
+        {
+          id: 'e2',
+          error_type: 'type',
+          message: 'Type mismatch: Expected string, got number',
+          file: 'src/types/config.ts',
+          line: 28,
+          timestamp: new Date(Date.now() - 1 * 60 * 60 * 1000)
+            .toISOString(),
+          severity: 'error',
+          suppressed: true,
+          correction: 'Type coercion applied. Investigate further.',
+        },
+        {
+          id: 'e3',
+          error_type: 'syntax',
+          message: 'Missing semicolon',
+          file: 'src/index.ts',
+          line: 5,
+          timestamp: new Date(Date.now() - 3000).toISOString(),
+          severity: 'warning',
+          suppressed: false,
+        },
+        {
+          id: 'e4',
+          error_type: 'semantic',
+          message: 'Unused import statement',
+          file: 'src/utils/helpers.ts',
+          line: 12,
+          timestamp: new Date(Date.now() - 5 * 60 * 60 * 1000)
+            .toISOString(),
+          severity: 'info',
+          suppressed: true,
+        },
+      ];
+
+      const typeFilter = (args.flags.type as string) || 'all';
+      const filter = (args.flags.filter as string) || 'all';
+
+      let results = mockErrors;
+
+      if (typeFilter !== 'all') {
+        results = results.filter(
+          (e) => e.error_type === typeFilter.toLowerCase()
+        );
+      }
+
+      if (filter === 'active') {
+        results = results.filter((e) => !e.suppressed);
+      } else if (filter === 'suppressed') {
+        results = results.filter((e) => e.suppressed);
+      }
+
+      if (args.flags.json) {
+        return {
+          success: true,
+          message: JSON.stringify(results, null, 2),
+          data: {
+            total: results.length,
+            active: results.filter((e) => !e.suppressed).length,
+            suppressed: results.filter((e) => e.suppressed).length,
+            errors: results,
+          },
+        };
+      }
+
+      let output = '\n📋 Error Registry\n';
+      output += '='.repeat(60) + '\n';
+
+      if (results.length === 0) {
+        output += '✨ No errors to display!\n';
+      } else {
+        for (const error of results) {
+          output += this.formatError(error);
+        }
+      }
+
+      output += '\n' + '='.repeat(60) + '\n';
+      output += `Active: ${results.filter((e) => !e.suppressed).length} | `;
+      output += `Suppressed: ${results.filter((e) => e.suppressed).length}\n`;
+
+      return {
+        success: true,
+        message: output,
+        data: {
+          total: results.length,
+          active: results.filter((e) => !e.suppressed).length,
+          suppressed: results.filter((e) => e.suppressed).length,
+          errors: results,
+        },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: 'Error reading error registry',
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  private formatError(error: ErrorEntry): string {
+    const statusIcon = error.suppressed ? '🔇' : '🔴';
+    const typeIcon = this.getTypeIcon(error.error_type);
+    const severityColor = this.getSeverityIcon(error.severity);
+
+    let output = `\n${statusIcon} ${typeIcon} [${error.error_type.toUpperCase()}] `;
+    output += `${severityColor} ${error.severity.toUpperCase()}\n`;
+    output += `   Message: ${error.message}\n`;
+    output += `   Location: ${error.file}:${error.line}\n`;
+    output += `   Time: ${new Date(error.timestamp).toLocaleString()}\n`;
+    output += `   ID: ${error.id}\n`;
+
+    if (error.correction) {
+      output += `   Fix: ${error.correction}\n`;
+    }
+
+    return output;
+  }
+
+  private getTypeIcon(type: string): string {
+    const icons: Record<string, string> = {
+      runtime: '⚡',
+      type: '🔤',
+      syntax: '📝',
+      semantic: '🧠',
+      default: '❓',
+    };
+    return icons[type.toLowerCase()] || icons.default;
+  }
+
+  private getSeverityIcon(severity: string): string {
+    const icons: Record<string, string> = {
+      error: '🔴',
+      warning: '🟡',
+      info: '🔵',
+    };
+    return icons[severity.toLowerCase()] || '❓';
+  }
+}
+
+export const errorsCommand = new ErrorsCommand();

package/src/commands/init.ts

@@ -0,0 +1,133 @@
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { CLIArgs, CommandResult, CliCommand, CLIConfig } from '../types';
+import { resolveProjectRoot } from '../utils';
+
+/**
+ * Init Command - Initialize a new Weave project
+ */
+export class InitCommand implements CliCommand {
+  name = 'init';
+  description = 'Initialize a new Weave project';
+  usage = 'weave init <project-name> [--root /path] [--include-tests]';
+  flags = {
+    root: {
+      short: 'r',
+      description: 'Project root directory',
+      default: '',
+    },
+    'include-tests': {
+      short: 't',
+      description: 'Include test files in analysis',
+      default: false,
+    },
+    verbose: {
+      short: 'v',
+      description: 'Verbose output',
+      default: false,
+    },
+  };
+
+  async execute(args: CLIArgs): Promise<CommandResult> {
+    try {
+      const projectName = args.args[0];
+      if (!projectName) {
+        return {
+          success: false,
+          message: 'Error: Project name is required',
+          error: 'Usage: weave init <project-name>',
+        };
+      }
+
+      const projectRoot = resolveProjectRoot(args.flags.root as string | undefined);
+      const weaveDir = join(projectRoot, '.weave');
+      const graphDbPath = join(weaveDir, 'graph.json');
+      const roadmapPath = join(weaveDir, 'ROADMAP.md');
+      const configPath = join(weaveDir, 'config.json');
+
+      // Check if .weave directory already exists
+      if (existsSync(weaveDir)) {
+        return {
+          success: false,
+          message: `Error: .weave directory already exists in ${projectRoot}`,
+          error: 'Project may already be initialized',
+        };
+      }
+
+      // Create .weave directory structure
+      mkdirSync(weaveDir, { recursive: true });
+
+      // Create config file
+      const config: CLIConfig = {
+        project_name: projectName,
+        project_root: projectRoot,
+        knowledge_graph_path: graphDbPath,
+        roadmap_file: roadmapPath,
+        include_tests: (args.flags['include-tests'] as boolean) || false,
+        max_context_depth: 5,
+        verbose: (args.flags.verbose as boolean) || false,
+        debug: false,
+      };
+
+      writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+      // Create empty graph database
+      const emptyGraph = {
+        created_at: new Date().toISOString(),
+        nodes: [],
+        edges: [],
+        sessions: {},
+      };
+      writeFileSync(graphDbPath, JSON.stringify(emptyGraph, null, 2));
+
+      // Create roadmap file
+      const roadmapContent = `# ${projectName} - Development Roadmap
+
+## Project Overview
+This roadmap tracks the development progress of ${projectName}.
+
+**Initialized:** ${new Date().toLocaleDateString()}
+
+## Milestones
+
+### Phase 0: Planning
+- [ ] Define project architecture
+- [ ] Set up development environment
+- [ ] Configure knowledge graph
+
+`;
+      writeFileSync(roadmapPath, roadmapContent);
+
+      const successMessage = `✅ Project "${projectName}" initialized successfully!
+
+📁 Created .weave directory in: ${projectRoot}
+📊 Knowledge graph created: ${graphDbPath}
+📋 Roadmap created: ${roadmapPath}
+⚙️  Config saved: ${configPath}
+
+Next steps:
+• Run 'weave status' to see project overview
+• Run 'weave orphans' to analyze code for unused exports
+• Run 'weave query <term>' to search the knowledge graph
+`;
+
+      return {
+        success: true,
+        message: successMessage,
+        data: {
+          project_name: projectName,
+          project_root: projectRoot,
+          weave_directory: weaveDir,
+        },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: 'Error initializing project',
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+}
+
+export const initCommand = new InitCommand();