@openweave/weave-cli 1.0.2

package/src/commands/query.ts

@@ -0,0 +1,170 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { CLIArgs, CommandResult, CliCommand } from '../types';
+import { resolveProjectRoot } from '../utils';
+
+interface GraphNode {
+  id: string;
+  label: string;
+  type: string;
+  description?: string;
+  frequency: number;
+  last_accessed?: string;
+}
+
+/**
+ * Query Command - Search the knowledge graph
+ */
+export class QueryCommand implements CliCommand {
+  name = 'query';
+  description = 'Search the knowledge graph for nodes and relationships';
+  usage = 'weave query <search-term> [--limit=10] [--type=all]';
+  flags = {
+    limit: {
+      short: 'l',
+      description: 'Maximum results to return (default: 10)',
+      default: '10',
+    },
+    type: {
+      short: 't',
+      description: 'Filter by node type (default: all)',
+      default: 'all',
+    },
+    json: {
+      short: 'j',
+      description: 'Output as JSON',
+      default: false,
+    },
+  };
+
+  async execute(args: CLIArgs): Promise<CommandResult> {
+    try {
+      const searchTerm = args.args[0];
+      if (!searchTerm) {
+        return {
+          success: false,
+          message: 'Error: Search term is required',
+          error: 'Usage: weave query <search-term>',
+        };
+      }
+
+      const projectRoot = resolveProjectRoot();
+      const weaveDir = join(projectRoot, '.weave');
+      const graphPath = join(weaveDir, 'graph.json');
+
+      if (!existsSync(graphPath)) {
+        return {
+          success: false,
+          message: 'Error: Knowledge graph not found',
+          error: 'Please run "weave init <project-name>" first',
+        };
+      }
+
+      // Mock search results for demonstration
+      const mockResults: GraphNode[] = [
+        {
+          id: 'n1',
+          label: 'initializeProject',
+          type: 'FUNCTION',
+          description: 'Initializes a new project with default settings',
+          frequency: 5,
+          last_accessed: new Date().toISOString().split('T')[0],
+        },
+        {
+          id: 'n2',
+          label: 'ProjectManager',
+          type: 'CLASS',
+          description: 'Manages project lifecycle and state',
+          frequency: 12,
+          last_accessed: new Date(Date.now() - 1 * 24 * 60 * 60 * 1000)
+            .toISOString()
+            .split('T')[0],
+        },
+        {
+          id: 'n3',
+          label: 'project_config',
+          type: 'VARIABLE',
+          description: 'Global configuration object',
+          frequency: 3,
+          last_accessed: new Date(Date.now() - 2 * 24 * 60 * 60 * 1000)
+            .toISOString()
+            .split('T')[0],
+        },
+      ];
+
+      const limit = parseInt((args.flags.limit as string) || '10', 10);
+      const typeFilter = (args.flags.type as string) || 'all';
+
+      let results = mockResults.filter((r) =>
+        r.label.toLowerCase().includes(searchTerm.toLowerCase())
+      );
+
+      if (typeFilter !== 'all') {
+        results = results.filter((r) => r.type === typeFilter.toUpperCase());
+      }
+
+      results = results.slice(0, limit);
+
+      if (args.flags.json) {
+        return {
+          success: true,
+          message: JSON.stringify(results, null, 2),
+          data: results,
+        };
+      }
+
+      let output = `\n🔍 Query Results for: "${searchTerm}"\n`;
+      output += '='.repeat(60) + '\n';
+
+      if (results.length === 0) {
+        output += 'No results found.\n';
+      } else {
+        for (const node of results) {
+          output += this.formatNode(node);
+        }
+      }
+
+      output += '\n' + '='.repeat(60) + '\n';
+      output += `Found: ${results.length} result(s)\n`;
+
+      return {
+        success: true,
+        message: output,
+        data: results,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: 'Error querying knowledge graph',
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  private formatNode(node: GraphNode): string {
+    const typeEmoji = {
+      FUNCTION: '📌',
+      CLASS: '🏛️',
+      INTERFACE: '📋',
+      ENUM: '📊',
+      TYPE: '📝',
+      VARIABLE: '📦',
+      METHOD: '🔧',
+      MODULE: '📚',
+    }[node.type] || '❓';
+
+    let output = `\n${typeEmoji} ${node.label} (${node.type})\n`;
+    if (node.description) {
+      output += `   Description: ${node.description}\n`;
+    }
+    output += `   ID: ${node.id}\n`;
+    output += `   Frequency: ${node.frequency} times\n`;
+    if (node.last_accessed) {
+      output += `   Last accessed: ${node.last_accessed}\n`;
+    }
+
+    return output;
+  }
+}
+
+export const queryCommand = new QueryCommand();

package/src/commands/save-node.ts

@@ -0,0 +1,161 @@
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { CLIArgs, CommandResult, CliCommand } from '../types';
+import { resolveProjectRoot } from '../utils';
+
+interface GraphNode {
+  id: string;
+  label: string;
+  type: string;
+  description?: string;
+  metadata?: Record<string, unknown>;
+  frequency?: number;
+  created_at: string;
+  updated_at: string;
+}
+
+/**
+ * SaveNode Command - Manually add or update a node in the knowledge graph
+ */
+export class SaveNodeCommand implements CliCommand {
+  name = 'save-node';
+  description = 'Manually add or update a node in the knowledge graph';
+  usage = 'weave save-node --label=<name> --type=<type> [--description=<desc>]';
+  flags = {
+    label: {
+      short: 'l',
+      description: 'Node label/name (required)',
+    },
+    type: {
+      short: 't',
+      description: 'Node type: function, class, variable, interface, enum, etc.',
+    },
+    description: {
+      short: 'd',
+      description: 'Node description/documentation',
+      default: '',
+    },
+    file: {
+      short: 'f',
+      description: 'Source file location',
+      default: '',
+    },
+    line: {
+      description: 'Line number in source file',
+      default: '0',
+    },
+    frequency: {
+      description: 'Reference frequency hint',
+      default: '1',
+    },
+    json: {
+      short: 'j',
+      description: 'Output as JSON',
+      default: false,
+    },
+  };
+
+  async execute(args: CLIArgs): Promise<CommandResult> {
+    try {
+      const label = args.flags.label as string;
+      const type = args.flags.type as string;
+
+      if (!label) {
+        return {
+          success: false,
+          message: 'Error: --label is required',
+          error: 'Usage: weave save-node --label=<name> --type=<type>',
+        };
+      }
+
+      if (!type) {
+        return {
+          success: false,
+          message: 'Error: --type is required',
+          error:
+            'Valid types: function, class, variable, interface, enum, module, type, method',
+        };
+      }
+
+      const projectRoot = resolveProjectRoot();
+      const weaveDir = join(projectRoot, '.weave');
+      const graphPath = join(weaveDir, 'graph.json');
+
+      if (!existsSync(graphPath)) {
+        return {
+          success: false,
+          message: 'Error: Knowledge graph not found',
+          error: 'Please run "weave init <project-name>" first',
+        };
+      }
+
+      // Read existing graph
+      const graphContent = readFileSync(graphPath, 'utf-8');
+      const graphData = JSON.parse(graphContent);
+
+      // Create new node
+      const nodeId = `node_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+      const now = new Date().toISOString();
+
+      const newNode: GraphNode = {
+        id: nodeId,
+        label,
+        type: type.toUpperCase(),
+        description: (args.flags.description as string) || undefined,
+        frequency: parseInt((args.flags.frequency as string) || '1', 10),
+        created_at: now,
+        updated_at: now,
+      };
+
+      if (args.flags.file) {
+        newNode.metadata = {
+          file: args.flags.file,
+          line: parseInt((args.flags.line as string) || '0', 10),
+        };
+      }
+
+      // Add to graph
+      graphData.nodes.push(newNode);
+
+      // Write back
+      writeFileSync(graphPath, JSON.stringify(graphData, null, 2));
+
+      if (args.flags.json) {
+        return {
+          success: true,
+          message: JSON.stringify(newNode, null, 2),
+          data: newNode,
+        };
+      }
+
+      const output = `
+✅ Node created successfully!
+
+📍 Node ID: ${newNode.id}
+📌 Label: ${newNode.label}
+🏷️  Type: ${newNode.type}
+${newNode.description ? `📝 Description: ${newNode.description}\n` : ''}
+
+Graph Statistics:
+• Total nodes: ${graphData.nodes.length}
+• Total edges: ${graphData.edges.length}
+
+Use 'weave query ${newNode.label}' to search for this node.
+`;
+
+      return {
+        success: true,
+        message: output,
+        data: newNode,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: 'Error saving node',
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+}
+
+export const saveNodeCommand = new SaveNodeCommand();

package/src/commands/skills.ts

@@ -0,0 +1,230 @@
+import { join } from 'node:path';
+import { CLIArgs, CommandResult, CliCommand } from '../types.js';
+import { resolveProjectRoot } from '../utils.js';
+import {
+  loadSkillConfig,
+  setSkillEnabled,
+  CONFIG_FILENAME,
+} from '@openweave/weave-skills';
+
+/**
+ * SkillsCommand — manage OpenWeave skill modules
+ *
+ * Subcommands:
+ *   weave skills list                  List all skills and their enabled state
+ *   weave skills enable <id>           Enable a skill in .weave.config.json
+ *   weave skills disable <id>          Disable a skill in .weave.config.json
+ *   weave skills info <id>             Show config entry for a skill
+ */
+export const skillsCommand: CliCommand = {
+  name: 'skills',
+  description: 'Manage OpenWeave skill modules',
+  usage: 'weave skills <list|enable|disable|info> [skill-id]',
+  flags: {
+    json: {
+      short: 'j',
+      description: 'Output as JSON',
+      default: false,
+    },
+  },
+
+  async execute(args: CLIArgs): Promise<CommandResult> {
+    const sub = args.args[0] ?? 'list';
+    const skillId = args.args[1];
+    const outputJson = Boolean(args.flags.json);
+    const projectRoot = resolveProjectRoot();
+
+    switch (sub) {
+      case 'list':
+        return handleList(projectRoot, outputJson);
+
+      case 'enable': {
+        if (!skillId) {
+          return {
+            success: false,
+            message: '❌ Usage: weave skills enable <skill-id>',
+            error: 'Missing skill id',
+          };
+        }
+        return handleSetEnabled(projectRoot, skillId, true, outputJson);
+      }
+
+      case 'disable': {
+        if (!skillId) {
+          return {
+            success: false,
+            message: '❌ Usage: weave skills disable <skill-id>',
+            error: 'Missing skill id',
+          };
+        }
+        return handleSetEnabled(projectRoot, skillId, false, outputJson);
+      }
+
+      case 'info': {
+        if (!skillId) {
+          return {
+            success: false,
+            message: '❌ Usage: weave skills info <skill-id>',
+            error: 'Missing skill id',
+          };
+        }
+        return handleInfo(projectRoot, skillId, outputJson);
+      }
+
+      default:
+        return {
+          success: false,
+          message: `❌ Unknown subcommand: "${sub}"\n\nUsage: weave skills <list|enable|disable|info>`,
+          error: `Unknown subcommand: ${sub}`,
+        };
+    }
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Handlers
+// ---------------------------------------------------------------------------
+
+function handleList(projectRoot: string, outputJson: boolean): CommandResult {
+  const config = loadSkillConfig(projectRoot);
+  const entries = Object.entries(config.skills);
+
+  if (outputJson) {
+    return {
+      success: true,
+      message: JSON.stringify(config.skills, null, 2),
+      data: config.skills,
+    };
+  }
+
+  const configFile = join(projectRoot, CONFIG_FILENAME);
+
+  if (entries.length === 0) {
+    return {
+      success: true,
+      message: [
+        '',
+        '🔧 OpenWeave Skills',
+        '─'.repeat(50),
+        '',
+        '  No skills configured yet.',
+        '',
+        '  Skills are enabled/disabled in:',
+        `  ${configFile}`,
+        '',
+        '  Example:',
+        '    weave skills enable auto-fix',
+        '    weave skills enable code-review',
+        '',
+        '  Available skill ids (Phase 9):',
+        '    auto-fix · code-review · test-gen · docs-gen · refactor',
+        '    pipeline-aware · dep-audit · perf-profile · container-advisor · deploy-provision',
+        '    onboarding · commit-composer · context-memory · multi-repo · cli-interactive',
+        '',
+      ].join('\n'),
+    };
+  }
+
+  const rows = entries.map(([id, enabled]) => {
+    const icon = enabled ? '✅' : '⬜';
+    const state = enabled ? 'enabled ' : 'disabled';
+    return `  ${icon}  ${state}  ${id}`;
+  });
+
+  return {
+    success: true,
+    message: [
+      '',
+      '🔧 OpenWeave Skills',
+      '─'.repeat(50),
+      '',
+      ...rows,
+      '',
+      `  Config: ${configFile}`,
+      '',
+      '  weave skills enable <id>   — activate a skill',
+      '  weave skills disable <id>  — deactivate a skill',
+      '',
+    ].join('\n'),
+    data: config.skills,
+  };
+}
+
+function handleSetEnabled(
+  projectRoot: string,
+  skillId: string,
+  enabled: boolean,
+  outputJson: boolean
+): CommandResult {
+  try {
+    setSkillEnabled(skillId, enabled, projectRoot);
+
+    const action = enabled ? 'enabled' : 'disabled';
+    const icon = enabled ? '✅' : '⬜';
+    const data = { skillId, enabled };
+
+    if (outputJson) {
+      return { success: true, message: JSON.stringify(data, null, 2), data };
+    }
+
+    return {
+      success: true,
+      message: `\n${icon} Skill '${skillId}' ${action} in ${CONFIG_FILENAME}\n`,
+      data,
+    };
+  } catch (err) {
+    return {
+      success: false,
+      message: `❌ Failed to update skill config`,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+function handleInfo(projectRoot: string, skillId: string, outputJson: boolean): CommandResult {
+  const config = loadSkillConfig(projectRoot);
+  const hasEntry = skillId in config.skills;
+
+  if (!hasEntry) {
+    if (outputJson) {
+      return {
+        success: false,
+        message: JSON.stringify({ skillId, configured: false }),
+        data: { skillId, configured: false },
+      };
+    }
+    return {
+      success: false,
+      message: [
+        '',
+        `⚠️  Skill '${skillId}' is not in ${CONFIG_FILENAME}`,
+        '',
+        `  To add it:`,
+        `    weave skills enable ${skillId}`,
+        `    weave skills disable ${skillId}`,
+        '',
+      ].join('\n'),
+      error: `Skill '${skillId}' not configured`,
+    };
+  }
+
+  const enabled = config.skills[skillId];
+  const data = { skillId, enabled, configured: true };
+
+  if (outputJson) {
+    return { success: true, message: JSON.stringify(data, null, 2), data };
+  }
+
+  return {
+    success: true,
+    message: [
+      '',
+      `🔧 Skill: ${skillId}`,
+      '─'.repeat(40),
+      `  Status : ${enabled ? '✅ enabled' : '⬜ disabled'}`,
+      `  Config : ${join(projectRoot, CONFIG_FILENAME)}`,
+      '',
+    ].join('\n'),
+    data,
+  };
+}

package/src/commands/status.ts

@@ -0,0 +1,122 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { CLIArgs, CommandResult, CliCommand, CLIConfig, ProjectState } from '../types';
+import { resolveProjectRoot } from '../utils';
+
+/**
+ * Status Command - Display project status
+ */
+export class StatusCommand implements CliCommand {
+  name = 'status';
+  description = 'Show current project status and progress';
+  usage = 'weave status [--verbose]';
+  flags = {
+    verbose: {
+      short: 'v',
+      description: 'Show detailed information',
+      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',
+        };
+      }
+
+      const configContent = readFileSync(configPath, 'utf-8');
+      const config: CLIConfig = JSON.parse(configContent);
+
+      const graphPath = join(weaveDir, 'graph.json');
+      let graphData = { nodes: [], edges: [], sessions: {} };
+
+      if (existsSync(graphPath)) {
+        const graphContent = readFileSync(graphPath, 'utf-8');
+        graphData = JSON.parse(graphContent);
+      }
+
+      const projectState: ProjectState = {
+        created_at: new Date(),
+        last_updated: new Date(),
+        session_id: `session_${Date.now()}`,
+        milestones: 0,
+        total_nodes: graphData.nodes.length,
+        total_edges: graphData.edges.length,
+        context_usage_percent: Math.min(
+          100,
+          ((graphData.nodes.length + graphData.edges.length) / 10000) * 100
+        ),
+      };
+
+      const outputJson = args.flags.json as boolean;
+
+      if (outputJson) {
+        return {
+          success: true,
+          message: JSON.stringify(projectState, null, 2),
+          data: projectState,
+        };
+      }
+
+      const verbose = args.flags.verbose as boolean;
+
+      const statusMessage = `
+📊 Project Status: ${config.project_name}
+${'-'.repeat(50)}
+
+📁 Location: ${config.project_root}
+🕒 Session: ${projectState.session_id}
+
+📈 Graph Statistics:
+   • Nodes: ${projectState.total_nodes}
+   • Edges: ${projectState.total_edges}
+   • Context Usage: ${projectState.context_usage_percent.toFixed(1)}%
+
+${verbose ? this.getVerboseInfo(config) : ''}
+
+✨ Quick Commands:
+   • weave query <term>     - Search the knowledge graph
+   • weave orphans          - Analyze code for unused exports
+   • weave milestones       - View milestone progress
+   • weave errors           - Show error registry
+`;
+
+      return {
+        success: true,
+        message: statusMessage,
+        data: projectState,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: 'Error reading project status',
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  private getVerboseInfo(config: CLIConfig): string {
+    return `
+⚙️  Configuration:
+   • Include Tests: ${config.include_tests}
+   • Max Context Depth: ${config.max_context_depth}
+   • Verbose Mode: ${config.verbose}
+   • Debug Mode: ${config.debug}
+`;
+  }
+}
+
+export const statusCommand = new StatusCommand();