动态技能管理器

npm install -g dsm

npm install dsm

npx dsm <command>

dsm status
# or
dsm st

DSM Status
  Execution Context: local
  Storage Path: /project/.dsm
  Ephemeral Mode: No

Installed Skills: 3/3
  - mcp: 2
  - vercel: 1

# List all installed skills
dsm list
# or
dsm ls

# Filter by source
dsm list --source mcp
dsm list --source vercel

# Filter by status
dsm list --status installed
dsm list --status enabled

# JSON output
dsm list --json

# Install with default (session) scope
dsm add mcp/github

# Install with specific scope
dsm add vercel/retry --scope project
dsm add mcp/postgres --scope global

# Force reinstall
dsm add mcp/github --force

# Alternate command
dsm install mcp/github

dsm remove mcp/github
# or
dsm rm mcp/github
# or
dsm uninstall mcp/github

# General search
dsm search react
dsm search database

# Filter by source
dsm search api --source mcp

# JSON output
dsm search testing --json

# List configured MCP servers
dsm mcp list

# Connect to an MCP server
dsm mcp connect my-server http://localhost:3000

# Disconnect from an MCP server
dsm mcp disconnect my-server

dsm analyze "build a REST API for user management"
dsm analyse "create a React component for data visualization"

# List saved bundles
dsm bundle list

# Show bundle details
dsm bundle show fullstack

# Remove a bundle
dsm bundle remove fullstack

dsm init

dsm version
# or
dsm v

src/
├── core/
│   ├── types.ts          # Type definitions (UnifiedSkill, Task, etc.)
│   ├── errors.ts         # DSMError class with 20+ error subclasses
│   └── execution-context.ts  # Execution context detection
├── adapters/
│   ├── base-adapter.ts   # BaseAdapter abstract class
│   ├── mcp-adapter.ts    # MCP server adapter (JSON-RPC over HTTP/stdio)
│   ├── vercel-adapter.ts # Vercel Skills adapter (SKILL.md parsing)
│   └── omc-adapter.ts    # OMC native skills adapter (.claude/skills parsing)
├── registry/
│   ├── skill-registry.ts # Skill registry with adapter management
│   └── bundle-storage.ts # Skill bundle persistence (bundles.json)
├── analyzer/
│   └── task-analyzer.ts  # Task analysis and skill scoring
├── cli/
│   └── index.ts          # Commander.js CLI with all commands
└── index.ts              # Main entry point

interface SkillAdapter {
  readonly source: SkillSource;
  discover(): Promise<UnifiedSkill[]>;
  install(skillId: string, options?: InstallOptions): Promise<UnifiedSkill>;
  uninstall(skillId: string): Promise<void>;
  isAvailable(skillId: string): Promise<boolean>;
}

interface UnifiedSkill {
  id: string;              // "source/id" format
  name: string;            // Human-readable name
  description: string;     // Skill description
  source: SkillSource;     // 'mcp' | 'vercel' | 'omc'
  version: string;         // Semantic version
  capabilities: Capability[];
  triggers: Trigger[];
  adapter: string;
  config: Record<string, unknown>;
  status: SkillStatus;
  scope: SkillScope;
  metadata: SkillMetadata;
}

{
  "outputFormat": "table",
  "defaultScope": "session",
  "autoEnable": true,
  "telemetryEnabled": false,
  "mcpServers": {
    "my-server": {
      "endpoint": "http://localhost:3000",
      "enabled": true
    }
  }
}

export DSM_HOME=/custom/path/to/dsm

import { SkillRegistry, MCPAdapter, VercelAdapter } from 'dynamic-skills';

// Create registry
const registry = new SkillRegistry();

// Register adapters
registry.registerAdapter('mcp', new MCPAdapter());
registry.registerAdapter('vercel', new VercelAdapter());

// Initialize
await registry.initialize();

// Search skills
const results = await registry.search({
  query: 'api',
  filters: { sources: ['mcp'] }
});

// Install a skill
const result = await registry.install('mcp/github', {
  scope: 'project'
});

// List installed skills
const skills = registry.getAll();

import { TaskAnalyzer } from 'dynamic-skills';

const analyzer = new TaskAnalyzer(registry);
const task = {
  id: 'task-1',
  input: 'Build a REST API for user management',
  context: { projectType: 'nodejs' }
};

const analysis = await analyzer.analyze(task);

console.log('Intent:', analysis.intent.intentType);
console.log('Confidence:', analysis.confidence);
console.log('Suggested skills:', analysis.suggestedSkills);

{
  code: string;           // Error code (e.g., 'SKILL_NOT_FOUND')
  message: string;        // Human-readable message
  severity: ErrorSeverity; // 'critical' | 'high' | 'medium' | 'low'
  category: ErrorCategory; // Error category
  timestamp: Date;        // When the error occurred
  context?: ErrorContext; // Additional context
  cause?: string;         // Root cause message
}

# Compile TypeScript
npm run build

# Watch mode
npm run build:watch

# Run CLI directly with ts-node
npm run dev

# Lint code
npm run lint

# Format code
npm run format

# Run tests
npm run test

# Run tests in watch mode
npm run test:watch

# Generate coverage report
npm run test:coverage

# Clean build artifacts
npm run clean

// src/adapters/my-adapter.ts
import { BaseAdapter } from './base-adapter.js';

export class MyAdapter extends BaseAdapter implements SkillAdapter {
  readonly type = 'my-source' as const;
  readonly name = 'My Adapter';
  readonly source = 'omc' as const;

  async discover(): Promise<UnifiedSkill[]> {
    // Discovery logic
  }

  async install(skillId: string, options?: InstallOptions): Promise<UnifiedSkill> {
    // Installation logic
  }

  async uninstall(skillId: string): Promise<void> {
    // Uninstallation logic
  }

  async isAvailable(skillId: string): Promise<boolean> {
    // Availability check
  }
}