@openweave/weave-cli 1.0.2

package/src/commands/migrate.ts

@@ -0,0 +1,239 @@
+import { join } from "path";
+import { CLIArgs, CommandResult, CliCommand } from "../types.js";
+import { IWeaveProvider, JsonProvider, MemoryProvider } from "@openweave/weave-provider";
+
+/**
+ * MigrateCommand
+ *
+ * Migrate data between any two registered OpenWeave providers.
+ *
+ * Usage:
+ *   weave migrate --from json --to sqlite
+ *   weave migrate --from sqlite --to json --data-dir /my/data
+ *   weave migrate --from json --to sqlite --dry-run
+ *
+ * Supported built-in providers (no external service needed):
+ *   json     — JSON files in --data-dir (default: .weave)
+ *   sqlite   — SQLite file via node:sqlite (requires @openweave/weave-provider-sqlite)
+ *   memory   — In-memory (useful for --dry-run inspection)
+ *
+ * Extended providers (require running services + extra packages):
+ *   mongodb  — requires @openweave/weave-provider-mongodb + WEAVE_MONGODB_URI
+ *   postgres — requires @openweave/weave-provider-postgres + WEAVE_POSTGRES_URL
+ *   mysql    — requires @openweave/weave-provider-mysql + WEAVE_MYSQL_URI
+ */
+export const migrateCommand: CliCommand = {
+  name: "migrate",
+  description: "Migrate data between OpenWeave storage providers",
+  usage: "weave migrate --from <source> --to <destination> [options]",
+  flags: {
+    from: {
+      short: "f",
+      description: "Source provider (json | sqlite | memory | mongodb | postgres | mysql)",
+      default: "json",
+    },
+    to: {
+      short: "t",
+      description: "Target provider (json | sqlite | memory | mongodb | postgres | mysql)",
+      default: "sqlite",
+    },
+    "data-dir": {
+      short: "d",
+      description: "Data directory for file-based providers (default: .weave)",
+      default: ".weave",
+    },
+    "db-file": {
+      description: "SQLite database file path (default: <data-dir>/weave.db)",
+      default: "",
+    },
+    prefix: {
+      short: "p",
+      description: "Migrate only keys matching this prefix (e.g. graph:)",
+      default: "",
+    },
+    "dry-run": {
+      description: "Preview what would be migrated without writing to destination",
+      default: false,
+    },
+    verbose: {
+      short: "v",
+      description: "Verbose output",
+      default: false,
+    },
+  },
+
+  async execute(args: CLIArgs): Promise<CommandResult> {
+    const fromName = (args.flags["from"] as string) || "json";
+    const toName = (args.flags["to"] as string) || "sqlite";
+    const dataDir = (args.flags["data-dir"] as string) || ".weave";
+    const dbFile = (args.flags["db-file"] as string) || join(dataDir, "weave.db");
+    const prefix = (args.flags["prefix"] as string) || undefined;
+    const dryRun = !!args.flags["dry-run"];
+    const verbose = !!args.flags["verbose"];
+
+    if (fromName === toName) {
+      return { success: false, message: "Source and destination providers must differ." };
+    }
+
+    const log = (msg: string) => { if (verbose) console.error(`  ${msg}`); };
+
+    let source: IWeaveProvider<unknown>;
+    let destination: IWeaveProvider<unknown>;
+
+    try {
+      source = await buildProvider(fromName, dataDir, dbFile, log);
+    } catch (err) {
+      return {
+        success: false,
+        message: `Failed to open source provider "${fromName}": ${(err as Error).message}`,
+      };
+    }
+
+    try {
+      if (!dryRun) {
+        destination = await buildProvider(toName, dataDir, dbFile + ".migrated", log);
+      } else {
+        destination = new MemoryProvider<unknown>();
+      }
+    } catch (err) {
+      await source.close().catch(() => {});
+      return {
+        success: false,
+        message: `Failed to open destination provider "${toName}": ${(err as Error).message}`,
+      };
+    }
+
+    try {
+      const keys = await source.list(prefix);
+
+      if (keys.length === 0) {
+        return {
+          success: true,
+          message: `No keys found${prefix ? ` matching prefix "${prefix}"` : ""}. Nothing to migrate.`,
+        };
+      }
+
+      log(`Found ${keys.length} key(s) to migrate...`);
+
+      let migrated = 0;
+      let failed = 0;
+      const errors: string[] = [];
+
+      for (const key of keys) {
+        try {
+          const value = await source.get(key);
+          if (value !== null) {
+            if (!dryRun) await destination.set(key, value);
+            migrated++;
+            log(`✓ ${key}`);
+          }
+        } catch (err) {
+          failed++;
+          errors.push(`  ${key}: ${(err as Error).message}`);
+          log(`✗ ${key}: ${(err as Error).message}`);
+        }
+      }
+
+      const dryRunNote = dryRun ? " [DRY RUN — no data written]" : "";
+      const summary = [
+        `Migration complete${dryRunNote}`,
+        `  From:      ${fromName}`,
+        `  To:        ${dryRun ? "memory (dry-run)" : toName}`,
+        `  Keys:      ${keys.length} found`,
+        `  Migrated:  ${migrated}`,
+        ...(failed > 0 ? [`  Failed:    ${failed}`, ...errors] : []),
+      ].join("\n");
+
+      return { success: failed === 0, message: summary };
+    } finally {
+      await source.close().catch(() => {});
+      if (!dryRun) await destination.close().catch(() => {});
+    }
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Factory: create a provider by name
+// ---------------------------------------------------------------------------
+
+async function buildProvider(
+  name: string,
+  dataDir: string,
+  dbFile: string,
+  log: (msg: string) => void
+): Promise<IWeaveProvider<unknown>> {
+  log(`Opening "${name}" provider...`);
+
+  switch (name) {
+    case "json":
+      return new JsonProvider(dataDir);
+
+    case "memory":
+      return new MemoryProvider<unknown>();
+
+    case "sqlite": {
+      // Dynamically import to avoid hard dep; package must be installed
+      const { SqliteProvider } = await import(
+        "@openweave/weave-provider-sqlite" as string
+      ).catch(() => {
+        throw new Error(
+          '"sqlite" provider requires @openweave/weave-provider-sqlite to be installed.'
+        );
+      });
+      return new (SqliteProvider as new (path: string) => IWeaveProvider<unknown>)(dbFile);
+    }
+
+    case "mongodb": {
+      const { MongoProvider } = await import(
+        "@openweave/weave-provider-mongodb" as string
+      ).catch(() => {
+        throw new Error(
+          '"mongodb" provider requires @openweave/weave-provider-mongodb to be installed.'
+        );
+      });
+      const uri = process.env["WEAVE_MONGODB_URI"] ?? "mongodb://localhost:27017";
+      return (MongoProvider as { connect(o: object): Promise<IWeaveProvider<unknown>> }).connect({
+        uri,
+      });
+    }
+
+    case "postgres": {
+      const { PostgresProvider } = await import(
+        "@openweave/weave-provider-postgres" as string
+      ).catch(() => {
+        throw new Error(
+          '"postgres" provider requires @openweave/weave-provider-postgres to be installed.'
+        );
+      });
+      const connectionString =
+        process.env["WEAVE_POSTGRES_URL"] ??
+        process.env["DATABASE_URL"] ??
+        "postgresql://postgres:postgres@localhost:5432/openweave";
+      return (
+        PostgresProvider as { connect(o: object): Promise<IWeaveProvider<unknown>> }
+      ).connect({ connectionString });
+    }
+
+    case "mysql": {
+      const { MysqlProvider } = await import(
+        "@openweave/weave-provider-mysql" as string
+      ).catch(() => {
+        throw new Error(
+          '"mysql" provider requires @openweave/weave-provider-mysql to be installed.'
+        );
+      });
+      const uri =
+        process.env["WEAVE_MYSQL_URI"] ??
+        process.env["DATABASE_URL"] ??
+        "mysql://root:root@localhost:3306/openweave";
+      return (MysqlProvider as { connect(o: object): Promise<IWeaveProvider<unknown>> }).connect({
+        uri,
+      });
+    }
+
+    default:
+      throw new Error(
+        `Unknown provider "${name}". Supported: json, sqlite, memory, mongodb, postgres, mysql.`
+      );
+  }
+}

package/src/commands/milestones.ts

@@ -0,0 +1,249 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { CLIArgs, CommandResult, CliCommand } from '../types';
+import { resolveProjectRoot } from '../utils';
+
+interface Milestone {
+  id: string;
+  name: string;
+  status: 'not_started' | 'in_progress' | 'completed' | 'blocked' | 'deferred';
+  priority: 'critical' | 'high' | 'medium' | 'low';
+  start_date?: string;
+  end_date?: string;
+  completion_percentage: number;
+  subtasks: {
+    id: string;
+    title: string;
+    status: 'not_started' | 'in_progress' | 'completed' | 'blocked' | 'deferred';
+    completed_date?: string;
+  }[];
+}
+
+/**
+ * Milestones Command - View project milestones and tasks
+ */
+export class MilestonesCommand implements CliCommand {
+  name = 'milestones';
+  description = 'List all milestones and sub-tasks';
+  usage = 'weave milestones [--filter=active] [--sort=priority]';
+  flags = {
+    filter: {
+      short: 'f',
+      description:
+        'Filter by status: all, active, completed, blocked (default: all)',
+      default: 'all',
+    },
+    sort: {
+      short: 's',
+      description: 'Sort by: priority, date, name (default: priority)',
+      default: 'priority',
+    },
+    json: {
+      short: 'j',
+      description: 'Output as JSON',
+      default: false,
+    },
+  };
+
+  async execute(args: CLIArgs): Promise<CommandResult> {
+    try {
+      const projectRoot = resolveProjectRoot();
+      const weaveDir = join(projectRoot, '.weave');
+      const roadmapPath = join(weaveDir, 'ROADMAP.md');
+
+      if (!existsSync(roadmapPath)) {
+        return {
+          success: false,
+          message: 'Error: ROADMAP.md not found',
+          error: 'Please run "weave init <project-name>" first',
+        };
+      }
+
+      // Mock milestones for demonstration
+      const mockMilestones: Milestone[] = [
+        {
+          id: 'm1',
+          name: 'Setup Development Environment',
+          status: 'completed',
+          priority: 'critical',
+          completion_percentage: 100,
+          subtasks: [
+            {
+              id: 'st1',
+              title: 'Install dependencies',
+              status: 'completed',
+              completed_date: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000)
+                .toISOString()
+                .split('T')[0],
+            },
+            {
+              id: 'st2',
+              title: 'Configure TypeScript',
+              status: 'completed',
+              completed_date: new Date(Date.now() - 6 * 24 * 60 * 60 * 1000)
+                .toISOString()
+                .split('T')[0],
+            },
+            {
+              id: 'st3',
+              title: 'Setup testing framework',
+              status: 'completed',
+              completed_date: new Date(Date.now() - 5 * 24 * 60 * 60 * 1000)
+                .toISOString()
+                .split('T')[0],
+            },
+          ],
+        },
+        {
+          id: 'm2',
+          name: 'Core Feature Implementation',
+          status: 'in_progress',
+          priority: 'critical',
+          start_date: new Date(Date.now() - 3 * 24 * 60 * 60 * 1000)
+            .toISOString()
+            .split('T')[0],
+          completion_percentage: 65,
+          subtasks: [
+            {
+              id: 'st4',
+              title: 'Implement knowledge graph',
+              status: 'completed',
+              completed_date: new Date(Date.now() - 2 * 24 * 60 * 60 * 1000)
+                .toISOString()
+                .split('T')[0],
+            },
+            {
+              id: 'st5',
+              title: 'Add orphan detection',
+              status: 'in_progress',
+            },
+            {
+              id: 'st6',
+              title: 'Implement milestone planner',
+              status: 'not_started',
+            },
+            {
+              id: 'st7',
+              title: 'Create MCP server',
+              status: 'not_started',
+            },
+          ],
+        },
+        {
+          id: 'm3',
+          name: 'CLI Development',
+          status: 'not_started',
+          priority: 'high',
+          completion_percentage: 0,
+          subtasks: [
+            {
+              id: 'st8',
+              title: 'Design CLI commands',
+              status: 'not_started',
+            },
+            {
+              id: 'st9',
+              title: 'Implement command handlers',
+              status: 'not_started',
+            },
+            {
+              id: 'st10',
+              title: 'Add help and documentation',
+              status: 'not_started',
+            },
+          ],
+        },
+      ];
+
+      const filter = (args.flags.filter as string) || 'all';
+      const filtered = this.filterMilestones(mockMilestones, filter);
+
+      if (args.flags.json) {
+        return {
+          success: true,
+          message: JSON.stringify(filtered, null, 2),
+          data: filtered,
+        };
+      }
+
+      let output = '\n📋 Project Milestones\n' + '='.repeat(60) + '\n';
+
+      for (const milestone of filtered) {
+        output += this.formatMilestone(milestone);
+      }
+
+      output += '\n' + '='.repeat(60) + '\n';
+      output += `Total: ${filtered.length} milestone(s)\n`;
+
+      return {
+        success: true,
+        message: output,
+        data: filtered,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: 'Error reading milestones',
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  private filterMilestones(
+    milestones: Milestone[],
+    filter: string
+  ): Milestone[] {
+    if (filter === 'all') return milestones;
+    if (filter === 'active')
+      return milestones.filter((m) => m.status === 'in_progress');
+    if (filter === 'completed')
+      return milestones.filter((m) => m.status === 'completed');
+    if (filter === 'blocked')
+      return milestones.filter((m) => m.status === 'blocked');
+    return milestones;
+  }
+
+  private formatMilestone(milestone: Milestone): string {
+    const statusIcon = {
+      completed: '✅',
+      in_progress: '🔄',
+      not_started: '🔜',
+      blocked: '⛔',
+      deferred: '⏸️',
+    }[milestone.status];
+
+    const priorityEmoji = {
+      critical: '🔴',
+      high: '🟠',
+      medium: '🟡',
+      low: '🟢',
+    }[milestone.priority];
+
+    let output = `\n${statusIcon} ${milestone.name} [${priorityEmoji} ${milestone.priority}]\n`;
+    output += `   Progress: ${this.progressBar(milestone.completion_percentage)} ${milestone.completion_percentage}%\n`;
+
+    if (milestone.subtasks && milestone.subtasks.length > 0) {
+      output += '   Sub-tasks:\n';
+      for (const subtask of milestone.subtasks) {
+        const subIcon = {
+          completed: '✓',
+          in_progress: '→',
+          not_started: '○',
+          blocked: '✗',
+          deferred: '–',
+        }[subtask.status];
+        output += `      [${subIcon}] ${subtask.title}\n`;
+      }
+    }
+
+    return output;
+  }
+
+  private progressBar(percentage: number, width: number = 20): string {
+    const filled = Math.round((percentage / 100) * width);
+    const empty = width - filled;
+    return '[' + '█'.repeat(filled) + '░'.repeat(empty) + ']';
+  }
+}
+
+export const milestonesCommand = new MilestonesCommand();

package/src/commands/orphans.ts

@@ -0,0 +1,210 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { CLIArgs, CommandResult, CliCommand } from '../types';
+import { resolveProjectRoot } from '../utils';
+
+interface OrphanEntity {
+  id: string;
+  name: string;
+  type: string;
+  file: string;
+  line: number;
+  severity: 'critical' | 'high' | 'medium' | 'low';
+  description: string;
+}
+
+/**
+ * Orphans Command - Detect unused code
+ */
+export class OrphansCommand implements CliCommand {
+  name = 'orphans';
+  description = 'Analyze code for orphaned (unused) entities';
+  usage = 'weave orphans [--severity=all] [--type=all]';
+  flags = {
+    severity: {
+      short: 's',
+      description: 'Filter by severity: all, critical, high, medium, low',
+      default: 'all',
+    },
+    type: {
+      short: 't',
+      description: 'Filter by entity type: all, function, class, variable',
+      default: 'all',
+    },
+    'include-tests': {
+      short: 'i',
+      description: 'Include test files in analysis',
+      default: false,
+    },
+    json: {
+      short: 'j',
+      description: 'Output as JSON',
+      default: false,
+    },
+  };
+
+  async execute(args: CLIArgs): Promise<CommandResult> {
+    try {
+      const projectRoot = resolveProjectRoot();
+      const weaveDir = join(projectRoot, '.weave');
+      const configPath = join(weaveDir, 'config.json');
+
+      if (!existsSync(configPath)) {
+        return {
+          success: false,
+          message: 'Error: .weave directory not found',
+          error: 'Please run "weave init <project-name>" first',
+        };
+      }
+
+      // Mock orphans data for demonstration
+      const mockOrphans: OrphanEntity[] = [
+        {
+          id: 'o1',
+          name: 'legacyParser',
+          type: 'function',
+          file: 'src/utils/parser.ts',
+          line: 42,
+          severity: 'high',
+          description: 'Parser function with no external references. Possibly replaced by new implementation.',
+        },
+        {
+          id: 'o2',
+          name: 'validateConfig',
+          type: 'function',
+          file: 'src/validators/config.ts',
+          line: 15,
+          severity: 'medium',
+          description: 'Exported function but only used internally in test files.',
+        },
+        {
+          id: 'o3',
+          name: 'DeprecatedClass',
+          type: 'class',
+          file: 'src/core/deprecated.ts',
+          line: 8,
+          severity: 'critical',
+          description: 'Class marked as exported but has no usages outside module. Consider removing.',
+        },
+        {
+          id: 'o4',
+          name: 'tempCache',
+          type: 'variable',
+          file: 'src/state/cache.ts',
+          line: 101,
+          severity: 'low',
+          description: 'Module-level variable possibly being phased out.',
+        },
+      ];
+
+      const severity = (args.flags.severity as string) || 'all';
+      const typeFilter = (args.flags.type as string) || 'all';
+
+      let results = mockOrphans;
+
+      if (severity !== 'all') {
+        results = results.filter((o) => o.severity === severity);
+      }
+
+      if (typeFilter !== 'all') {
+        results = results.filter(
+          (o) => o.type.toLowerCase() === typeFilter.toLowerCase()
+        );
+      }
+
+      if (args.flags.json) {
+        return {
+          success: true,
+          message: JSON.stringify(results, null, 2),
+          data: {
+            total: results.length,
+            by_severity: this.groupBySeverity(results),
+            orphans: results,
+          },
+        };
+      }
+
+      let output = '\n🔎 Code Analysis: Orphaned Entities\n';
+      output += '='.repeat(60) + '\n';
+
+      if (results.length === 0) {
+        output += '✨ No orphaned entities detected!\n';
+      } else {
+        const bySeverity = this.groupBySeverity(results);
+
+        for (const sev of ['critical', 'high', 'medium', 'low']) {
+          if (bySeverity[sev] && bySeverity[sev].length > 0) {
+            output += `\n${this.getSeverityIcon(sev as any)} ${sev.toUpperCase()} (${bySeverity[sev].length})\n`;
+            output += '-'.repeat(40) + '\n';
+
+            for (const orphan of bySeverity[sev]) {
+              output += this.formatOrphan(orphan);
+            }
+          }
+        }
+      }
+
+      output += '\n' + '='.repeat(60) + '\n';
+      output += `Total orphaned entities: ${results.length}\n`;
+      output += 'Recommendation: Remove or refactor unused code regularly.\n';
+
+      return {
+        success: true,
+        message: output,
+        data: {
+          total: results.length,
+          by_severity: this.groupBySeverity(results),
+          orphans: results,
+        },
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: 'Error analyzing orphans',
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  private groupBySeverity(orphans: OrphanEntity[]): Record<string, OrphanEntity[]> {
+    return {
+      critical: orphans.filter((o) => o.severity === 'critical'),
+      high: orphans.filter((o) => o.severity === 'high'),
+      medium: orphans.filter((o) => o.severity === 'medium'),
+      low: orphans.filter((o) => o.severity === 'low'),
+    };
+  }
+
+  private getSeverityIcon(
+    severity: 'critical' | 'high' | 'medium' | 'low'
+  ): string {
+    const icons = {
+      critical: '🔴',
+      high: '🟠',
+      medium: '🟡',
+      low: '🟢',
+    };
+    return icons[severity];
+  }
+
+  private getTypeIcon(type: string): string {
+    const icons: Record<string, string> = {
+      function: '📌',
+      class: '🏛️',
+      variable: '📦',
+      interface: '📋',
+      enum: '📊',
+      default: '❓',
+    };
+    return icons[type.toLowerCase()] || icons.default;
+  }
+
+  private formatOrphan(orphan: OrphanEntity): string {
+    let output = `   ${this.getTypeIcon(orphan.type)} ${orphan.name}\n`;
+    output += `       File: ${orphan.file}:${orphan.line}\n`;
+    output += `       ${orphan.description}\n`;
+    return output;
+  }
+}
+
+export const orphansCommand = new OrphansCommand();