deeper-cli 1.0.0

package/src/skills/SkillEngine.ts

@@ -0,0 +1,158 @@
+import { SkillRegistry } from './SkillRegistry.js';
+import { SkillLoader } from './SkillLoader.js';
+import { SkillExecutor } from './SkillExecutor.js';
+import { SkillCreator } from './SkillCreator.js';
+import { SkillTrigger } from './SkillTrigger.js';
+import { EventBus, Events } from '../core/eventbus.js';
+import type { Skill, SkillExecutionResult } from './types.js';
+
+export class SkillEngine {
+  private registry: SkillRegistry;
+  private loader: SkillLoader;
+  private executor: SkillExecutor;
+  private creator: SkillCreator;
+  private trigger: SkillTrigger;
+  private eventbus: EventBus;
+
+  constructor(eventbus?: EventBus) {
+    this.registry = new SkillRegistry();
+    this.loader = new SkillLoader();
+    this.executor = new SkillExecutor();
+    this.creator = new SkillCreator();
+    this.trigger = new SkillTrigger(this.registry);
+    this.eventbus = eventbus || new EventBus();
+  }
+
+  getRegistry(): SkillRegistry {
+    return this.registry;
+  }
+
+  getLoader(): SkillLoader {
+    return this.loader;
+  }
+
+  getTrigger(): SkillTrigger {
+    return this.trigger;
+  }
+
+  async loadAll(): Promise<number> {
+    const results = await this.loader.loadAll();
+    let count = 0;
+
+    for (const result of results) {
+      this.registry.register(result.skill);
+      count++;
+      this.eventbus.emit(Events.SKILL_LOADED, {
+        name: result.skill.meta.name,
+        source: result.source,
+        hasCode: !!result.skill.code,
+      });
+    }
+
+    return count;
+  }
+
+  async reload(): Promise<number> {
+    this.registry.clear();
+    return this.loadAll();
+  }
+
+  async execute(name: string, context: Record<string, unknown>): Promise<SkillExecutionResult> {
+    const skill = this.registry.get(name);
+    if (!skill) {
+      return {
+        success: false,
+        output: '',
+        error: `Skill not found: ${name}`,
+        duration: 0,
+      };
+    }
+
+    const startTime = Date.now();
+    try {
+      const result = await this.executor.execute(skill, context);
+      const duration = Date.now() - startTime;
+
+      this.eventbus.emit(Events.SKILL_EXECUTED, {
+        name: skill.meta.name,
+        success: result.success,
+        duration,
+      });
+
+      return { ...result, duration };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const errMsg = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        output: '',
+        error: errMsg,
+        duration,
+      };
+    }
+  }
+
+  async createSkill(
+    name: string,
+    description: string,
+    content: string,
+    code?: string,
+  ): Promise<Skill> {
+    const skill = await this.creator.create({
+      meta: {
+        name,
+        description,
+        version: '1.0.0',
+        author: 'DeeperCode AI',
+        triggers: [],
+        tools: [],
+        dependencies: [],
+      },
+      content,
+      code,
+    });
+
+    this.registry.register(skill);
+
+    this.eventbus.emit(Events.SKILL_CREATED, {
+      name: skill.meta.name,
+      description: skill.meta.description,
+    });
+
+    return skill;
+  }
+
+  matchTriggers(input: string): Skill[] {
+    const matches = this.trigger.match(input);
+    for (const skill of matches) {
+      this.eventbus.emit(Events.SKILL_TRIGGERED, {
+        name: skill.meta.name,
+        input: input.slice(0, 100),
+      });
+    }
+    return matches;
+  }
+
+  getSystemPrompt(context?: Record<string, unknown>): string {
+    const allSkills = this.registry.getAll();
+    if (allSkills.length === 0) return '';
+
+    let prompt = 'Available Skills:\n\n';
+    for (const skill of allSkills) {
+      prompt += `## ${skill.meta.name} (v${skill.meta.version})\n`;
+      prompt += `${skill.meta.description}\n`;
+
+      if (skill.meta.triggers.length > 0) {
+        prompt += `Triggers: ${skill.meta.triggers.join(', ')}\n`;
+      }
+
+      prompt += `---\n${skill.content.slice(0, 1000)}\n`;
+      if (skill.content.length > 1000) {
+        prompt += '...(truncated)\n';
+      }
+      prompt += '\n';
+    }
+
+    return prompt;
+  }
+}

package/src/skills/SkillExecutor.ts

@@ -0,0 +1,107 @@
+import type { Skill, SkillExecutionResult } from './types.js';
+
+interface ExecutionContext {
+  skill: Skill;
+  params: Record<string, unknown>;
+  env: Record<string, string>;
+}
+
+export class SkillExecutor {
+  async execute(skill: Skill, context: Record<string, unknown>): Promise<SkillExecutionResult> {
+    const startTime = Date.now();
+
+    try {
+      let output = '';
+
+      if (skill.code) {
+        const codeResult = await this.runCode(skill.code, {
+          skill,
+          params: context,
+          env: process.env as Record<string, string>,
+        });
+        output += codeResult;
+      }
+
+      if (!output) {
+        output = `Skill "${skill.meta.name}" instructions ready for AI processing.\n`;
+        output += `Description: ${skill.meta.description}\n`;
+        output += `---\n${skill.content}\n---`;
+      }
+
+      return {
+        success: true,
+        output,
+        duration: Date.now() - startTime,
+      };
+    } catch (error) {
+      const errMsg = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        output: '',
+        error: errMsg,
+        duration: Date.now() - startTime,
+      };
+    }
+  }
+
+  async runCode(code: string, ctx: ExecutionContext): Promise<string> {
+    const lines: string[] = [];
+
+    const sandbox = {
+      console: {
+        log: (...args: unknown[]) => {
+          lines.push(args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' '));
+        },
+        warn: (...args: unknown[]) => {
+          lines.push('[WARN] ' + args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' '));
+        },
+        error: (...args: unknown[]) => {
+          lines.push('[ERROR] ' + args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' '));
+        },
+      },
+      skill: ctx.skill,
+      params: ctx.params,
+      env: ctx.env,
+      fetch: globalThis.fetch,
+      setTimeout: globalThis.setTimeout,
+      clearTimeout: globalThis.clearTimeout,
+      JSON: JSON,
+      Math: Math,
+      Date: Date,
+      Object: Object,
+      Array: Array,
+      String: String,
+      Number: Number,
+      Boolean: Boolean,
+      Map: Map,
+      Set: Set,
+      RegExp: RegExp,
+      Error: Error,
+      Promise: Promise,
+    };
+
+    try {
+      const wrappedCode = `
+        return (async () => {
+          ${code}
+        })();
+      `;
+
+      const fn = new Function(
+        ...Object.keys(sandbox),
+        wrappedCode,
+      );
+
+      const result = await fn(...Object.values(sandbox));
+
+      if (result !== undefined && result !== null) {
+        lines.push(typeof result === 'string' ? result : JSON.stringify(result, null, 2));
+      }
+
+      return lines.join('\n');
+    } catch (error) {
+      const errMsg = error instanceof Error ? error.message : String(error);
+      return `Code execution error: ${errMsg}\n${lines.join('\n')}`;
+    }
+  }
+}

package/src/skills/SkillLoader.ts

@@ -0,0 +1,182 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { existsSync, watch } from 'node:fs';
+import { join } from 'node:path';
+import { DEEPER_SKILLS_DIR, PROJECT_SKILLS_DIR } from '../core/constants.js';
+import type { Skill, SkillMeta, SkillLoadResult } from './types.js';
+
+function parseSimpleYaml(s: string): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+  const lines = s.split('\n');
+  let listKey = '';
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const listMatch = trimmed.match(/^\s*-\s+(.+)/);
+    if (listMatch && listKey) {
+      const arr = (result[listKey] as string[]) || [];
+      arr.push(listMatch[1]);
+      result[listKey] = arr;
+      continue;
+    }
+    const kv = trimmed.match(/^([^:]+):\s*(.*)/);
+    if (kv) {
+      listKey = kv[2] === '' ? kv[1].trim() : '';
+      if (!listKey) result[kv[1].trim()] = kv[2].trim();
+    }
+  }
+  return result;
+}
+
+interface FrontmatterResult {
+  meta: SkillMeta;
+  body: string;
+}
+
+export class SkillLoader {
+  private scanDirs: string[];
+  private watchers: Array<ReturnType<typeof watch>> = [];
+
+  constructor(additionalDirs?: string[]) {
+    this.scanDirs = [DEEPER_SKILLS_DIR, PROJECT_SKILLS_DIR];
+    if (additionalDirs) {
+      this.scanDirs.push(...additionalDirs);
+    }
+  }
+
+  async loadAll(): Promise<SkillLoadResult[]> {
+    const results: SkillLoadResult[] = [];
+
+    for (const dir of this.scanDirs) {
+      if (!existsSync(dir)) continue;
+      const dirResults = await this.scanDirectory(dir);
+      results.push(...dirResults);
+    }
+
+    return results;
+  }
+
+  async loadSingle(dirPath: string, skillName: string): Promise<SkillLoadResult | null> {
+    const mdPath = join(dirPath, skillName, 'skill.md');
+    const jsPath = join(dirPath, skillName, 'skill.js');
+
+    if (!existsSync(mdPath)) return null;
+
+    try {
+      const mdContent = await readFile(mdPath, 'utf-8');
+      const { meta, body } = this.parseFrontmatter(mdContent);
+
+      let code: string | undefined;
+      if (existsSync(jsPath)) {
+        code = await readFile(jsPath, 'utf-8');
+      }
+
+      const skill: Skill = { meta, content: body, code };
+
+      return {
+        skill,
+        source: dirPath,
+        fromCodeFile: !!code,
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  startWatching(callback: (result: SkillLoadResult) => void): void {
+    for (const dir of this.scanDirs) {
+      if (!existsSync(dir)) continue;
+
+      try {
+        const watcher = watch(dir, { recursive: true }, async (_eventType, filename) => {
+          if (!filename) return;
+          const parts = filename.toString().split(/[/\\]/);
+          if (parts.length < 2) return;
+
+          const skillName = parts[0];
+          const result = await this.loadSingle(dir, skillName);
+          if (result) {
+            callback(result);
+          }
+        });
+        this.watchers.push(watcher);
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  stopWatching(): void {
+    for (const watcher of this.watchers) {
+      watcher.close();
+    }
+    this.watchers = [];
+  }
+
+  private async scanDirectory(dirPath: string): Promise<SkillLoadResult[]> {
+    const results: SkillLoadResult[] = [];
+
+    try {
+      const entries = await readdir(dirPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+
+        const skillDir = join(dirPath, entry.name);
+        const mdFile = join(skillDir, 'skill.md');
+
+        if (!existsSync(mdFile)) continue;
+
+        const result = await this.loadSingle(dirPath, entry.name);
+        if (result) {
+          results.push(result);
+        }
+      }
+    } catch {
+      // Directory may not exist yet
+    }
+
+    return results;
+  }
+
+  private parseFrontmatter(markdown: string): FrontmatterResult {
+    const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+    const match = markdown.match(frontmatterRegex);
+
+    if (!match) {
+      return {
+        meta: {
+          name: 'unnamed',
+          description: 'No description',
+          version: '1.0.0',
+          author: 'unknown',
+          triggers: [],
+          tools: [],
+          dependencies: [],
+        },
+        body: markdown,
+      };
+    }
+
+    const yamlContent = match[1];
+    const body = match[2];
+
+    let parsed: Record<string, unknown> = {};
+    try {
+      parsed = parseSimpleYaml(yamlContent) as Record<string, unknown>;
+    } catch {
+      // If YAML parsing fails, use defaults
+    }
+
+    const meta: SkillMeta = {
+      name: (parsed.name as string) || 'unnamed',
+      description: (parsed.description as string) || 'No description',
+      version: (parsed.version as string) || '1.0.0',
+      author: (parsed.author as string) || 'unknown',
+      triggers: Array.isArray(parsed.triggers) ? parsed.triggers.map(String) : [],
+      tools: Array.isArray(parsed.tools) ? parsed.tools.map(String) : [],
+      dependencies: Array.isArray(parsed.dependencies) ? parsed.dependencies.map(String) : [],
+    };
+
+    return { meta, body };
+  }
+}

package/src/skills/SkillRegistry.ts

@@ -0,0 +1,73 @@
+import type { Skill, SkillMeta } from './types.js';
+
+export class SkillRegistry {
+  private skills = new Map<string, Skill>();
+
+  register(skill: Skill): void {
+    if (this.skills.has(skill.meta.name)) {
+      throw new Error(`Skill already registered: ${skill.meta.name}`);
+    }
+    this.skills.set(skill.meta.name, skill);
+  }
+
+  unregister(name: string): boolean {
+    return this.skills.delete(name);
+  }
+
+  get(name: string): Skill | undefined {
+    return this.skills.get(name);
+  }
+
+  getAll(): Skill[] {
+    return Array.from(this.skills.values());
+  }
+
+  findByTrigger(trigger: string): Skill[] {
+    const lowerTrigger = trigger.toLowerCase();
+    const matches: Skill[] = [];
+
+    for (const skill of this.skills.values()) {
+      if (skill.meta.triggers.some((t) => lowerTrigger.includes(t.toLowerCase()))) {
+        matches.push(skill);
+      }
+    }
+
+    return matches;
+  }
+
+  findByTool(toolName: string): Skill[] {
+    const matches: Skill[] = [];
+
+    for (const skill of this.skills.values()) {
+      if (skill.meta.tools.includes(toolName)) {
+        matches.push(skill);
+      }
+    }
+
+    return matches;
+  }
+
+  findByDependency(depName: string): Skill[] {
+    const matches: Skill[] = [];
+
+    for (const skill of this.skills.values()) {
+      if (skill.meta.dependencies.includes(depName)) {
+        matches.push(skill);
+      }
+    }
+
+    return matches;
+  }
+
+  getMeta(): SkillMeta[] {
+    return Array.from(this.skills.values()).map((s) => s.meta);
+  }
+
+  clear(): void {
+    this.skills.clear();
+  }
+
+  get size(): number {
+    return this.skills.size;
+  }
+}

package/src/skills/SkillTrigger.ts

@@ -0,0 +1,82 @@
+import type { Skill } from './types.js';
+import type { SkillRegistry } from './SkillRegistry.js';
+
+interface TriggerMatch {
+  skill: Skill;
+  score: number;
+  matchedTriggers: string[];
+}
+
+export class SkillTrigger {
+  private registry: SkillRegistry;
+
+  constructor(registry: SkillRegistry) {
+    this.registry = registry;
+  }
+
+  match(input: string): Skill[] {
+    const lowerInput = input.toLowerCase();
+    const matches: TriggerMatch[] = [];
+
+    for (const skill of this.registry.getAll()) {
+      const matchedTriggers: string[] = [];
+      let score = 0;
+
+      for (const trigger of skill.meta.triggers) {
+        const lowerTrigger = trigger.toLowerCase();
+        if (lowerInput.includes(lowerTrigger)) {
+          matchedTriggers.push(trigger);
+          score += lowerTrigger.length;
+        }
+      }
+
+      const nameMatch = skill.meta.name.toLowerCase();
+      if (lowerInput.includes(nameMatch)) {
+        matchedTriggers.push(skill.meta.name);
+        score += nameMatch.length * 2;
+      }
+
+      const descWords = skill.meta.description.toLowerCase().split(/\s+/);
+      for (const word of descWords) {
+        if (word.length > 3 && lowerInput.includes(word)) {
+          score += 1;
+        }
+      }
+
+      if (matchedTriggers.length > 0 || score > 0) {
+        matches.push({ skill, score, matchedTriggers });
+      }
+    }
+
+    matches.sort((a, b) => b.score - a.score);
+
+    return matches.map((m) => m.skill);
+  }
+
+  getRecommendedSkills(input: string, maxResults: number = 3): Array<{
+    skill: Skill;
+    reason: string;
+  }> {
+    const matched = this.match(input).slice(0, maxResults);
+
+    return matched.map((skill) => {
+      const reasons: string[] = [];
+
+      const lowerInput = input.toLowerCase();
+      for (const trigger of skill.meta.triggers) {
+        if (lowerInput.includes(trigger.toLowerCase())) {
+          reasons.push(`matched trigger: "${trigger}"`);
+        }
+      }
+
+      if (lowerInput.includes(skill.meta.name.toLowerCase())) {
+        reasons.push(`matched name: "${skill.meta.name}"`);
+      }
+
+      return {
+        skill,
+        reason: reasons.length > 0 ? reasons.join(', ') : 'contextually relevant',
+      };
+    });
+  }
+}

package/src/skills/types.ts

@@ -0,0 +1,28 @@
+export interface SkillMeta {
+  name: string;
+  description: string;
+  version: string;
+  author: string;
+  triggers: string[];
+  tools: string[];
+  dependencies: string[];
+}
+
+export interface Skill {
+  meta: SkillMeta;
+  content: string;
+  code?: string;
+}
+
+export interface SkillExecutionResult {
+  success: boolean;
+  output: string;
+  error?: string;
+  duration: number;
+}
+
+export interface SkillLoadResult {
+  skill: Skill;
+  source: string;
+  fromCodeFile: boolean;
+}