wtt-connect 0.2.63 → 0.2.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wtt-connect",
-  "version": "0.2.63",
+  "version": "0.2.64",
   "private": false,
   "description": "WTT-native connector daemon for Codex, Claude Code, Cursor, Gemini, ACP, and other coding agent surfaces.",
   "type": "module",

package/src/runner.js

@@ -228,8 +228,9 @@ export class Runner {
           return;
         }
       }
+      const skillSlashPrompt = isSlashPassthrough ? this.skillSlashPrompt(content, m.metadata) : '';
       const compactSummary = this.store.getSession(sessionKey).compactSummary || '';
-      const prompt = isSlashPassthrough ? content : [
+      const prompt = isSlashPassthrough ? (skillSlashPrompt || content) : [
         'You are replying to a WTT Web conversation. Do not mention implementation internals unless asked.',
         `WTT topic_id: ${topicId}`,
         `WTT topic_type: ${messageTopicType(m) || 'unknown'}`,
@@ -434,6 +435,12 @@ export class Runner {
     return `${adapterDisplayName(adapter.name)} session cleared for this WTT topic. The next turn starts a fresh agent thread/session.`;
   }
 
+  skillSlashPrompt(content, metadata = null) {
+    const runtime = this.runtimeInfo();
+    const commands = Array.isArray(runtime.skill_commands) ? runtime.skill_commands : [];
+    return buildSkillSlashPrompt(content, metadata, commands);
+  }
+
   async compactAdapterSession(adapter, context = {}, command = '/compact', args = '') {
     const sessionKey = context.sessionKey || 'default';
     const topicId = String(context.topicId || '').trim();
@@ -764,6 +771,33 @@ export class Runner {
   }
 }
 
+export function buildSkillSlashPrompt(content, metadata = null, commands = []) {
+  const parsed = parseSlashCommand(content);
+  if (!parsed) return '';
+  const meta = parseMetadata(metadata);
+  const metadataSkillId = String(meta?.skill_id || meta?.skillId || '').trim();
+  const metadataFamily = String(meta?.command_family || meta?.commandFamily || '').trim().toLowerCase();
+  const matched = (Array.isArray(commands) ? commands : []).find((item) => String(item?.cmd || '').trim().toLowerCase() === parsed.command)
+    || (metadataFamily === 'skill' || metadataSkillId ? {
+      cmd: parsed.command,
+      skill_id: metadataSkillId || parsed.command.replace(/^\/+/, ''),
+      name: metadataSkillId || parsed.command.replace(/^\/+/, ''),
+      desc: '',
+    } : null);
+  if (!matched) return '';
+  const skillName = String(matched.name || matched.skill_id || matched.cmd || '').trim().replace(/^\/+/, '');
+  const skillId = String(matched.skill_id || skillName).trim();
+  const args = String(parsed.args || '').trim();
+  return [
+    `Use the ${skillName} skill${skillId && skillId !== skillName ? ` (${skillId})` : ''}.`,
+    matched.desc ? `Skill description: ${matched.desc}` : null,
+    '',
+    args ? `User request: ${args}` : 'User request: Run this skill for the current conversation.',
+    '',
+    `Original slash command: ${content}`,
+  ].filter(Boolean).join('\n');
+}
+
 function adapterDisplayName(name) {
   if (name === 'claude-code') return 'Claude Code';
   if (name === 'codex') return 'Codex';

package/src/runtime-info.js

@@ -3,6 +3,9 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { execFileSync } from 'node:child_process';
 
+let skillCommandCache = { at: 0, commands: [] };
+const SKILL_COMMAND_CACHE_MS = 60_000;
+
 export function buildRuntimeInfo(config, runtimeState = {}) {
   const workdir = resolveWorkDir(config.workDir);
   const git = gitInfo(workdir);
@@ -30,10 +33,145 @@ export function buildRuntimeInfo(config, runtimeState = {}) {
     node: process.version,
     mode: config.mode,
     git,
+    skill_commands: discoverSkillCommands(config, workdir),
     updated_at: new Date().toISOString(),
   };
 }
 
+export function discoverSkillCommands(config = {}, workdir = resolveWorkDir(config.workDir)) {
+  const now = Date.now();
+  if (now - skillCommandCache.at < SKILL_COMMAND_CACHE_MS) return skillCommandCache.commands;
+  const roots = skillRoots(config, workdir);
+  const seenCommands = new Set();
+  const commands = [];
+  for (const root of roots) {
+    for (const skillFile of findSkillFiles(root, 5)) {
+      const parsed = parseSkillFile(skillFile);
+      if (!parsed.id) continue;
+      const commandName = normalizeSkillCommandName(parsed.name || parsed.id);
+      if (!commandName) continue;
+      const cmd = `/${commandName}`;
+      const key = cmd.toLowerCase();
+      if (seenCommands.has(key)) continue;
+      seenCommands.add(key);
+      commands.push({
+        cmd,
+        desc: parsed.description || `Use ${parsed.name || parsed.id} skill`,
+        family: 'skill',
+        mode: 'passthrough',
+        skill_id: parsed.id,
+        name: parsed.name || parsed.id,
+        source: parsed.source,
+      });
+      if (commands.length >= 120) break;
+    }
+    if (commands.length >= 120) break;
+  }
+  skillCommandCache = { at: now, commands };
+  return commands;
+}
+
+function skillRoots(config = {}, workdir = '') {
+  const home = os.homedir();
+  const roots = [
+    path.join(home, '.codex', 'skills'),
+    path.join(home, '.agents', 'skills'),
+    path.join(home, '.claude', 'skills'),
+    path.join(home, '.claude', 'mattpocock-skills', 'skills'),
+    workdir ? path.join(workdir, '.codex', 'skills') : '',
+    workdir ? path.join(workdir, '.claude', 'skills') : '',
+    process.cwd() ? path.join(process.cwd(), '.codex', 'skills') : '',
+    process.cwd() ? path.join(process.cwd(), '.claude', 'skills') : '',
+  ];
+  const extra = String(process.env.WTT_CONNECT_SKILL_ROOTS || config.skillRoots || '').split(path.delimiter);
+  return Array.from(new Set(
+    [...roots, ...extra]
+      .map((item) => String(item || '').trim())
+      .filter(Boolean)
+      .map((item) => path.resolve(item))
+  ));
+}
+
+function findSkillFiles(root, maxDepth = 4) {
+  const out = [];
+  if (!root || !fs.existsSync(root)) return out;
+  const visit = (dir, depth) => {
+    if (depth < 0 || out.length >= 160) return;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    if (entries.some((entry) => entry.isFile() && entry.name === 'SKILL.md')) {
+      out.push(path.join(dir, 'SKILL.md'));
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name === 'node_modules' || entry.name.startsWith('.git')) continue;
+      visit(path.join(dir, entry.name), depth - 1);
+      if (out.length >= 160) return;
+    }
+  };
+  visit(root, maxDepth);
+  return out;
+}
+
+function parseSkillFile(file) {
+  try {
+    const text = fs.readFileSync(file, 'utf8');
+    const fallbackId = path.basename(path.dirname(file));
+    const frontmatter = text.match(/^---\s*\n([\s\S]*?)\n---/);
+    const meta = frontmatter ? parseSimpleYaml(frontmatter[1]) : {};
+    const id = String(meta.name || fallbackId || '').trim();
+    return {
+      id,
+      name: id,
+      description: String(meta.description || firstMarkdownSentence(text) || '').trim(),
+      source: sourceForSkillPath(file),
+    };
+  } catch {
+    return { id: '', name: '', description: '', source: 'local' };
+  }
+}
+
+function parseSimpleYaml(text) {
+  const out = {};
+  for (const line of String(text || '').split(/\r?\n/)) {
+    const match = line.match(/^([A-Za-z0-9_-]+)\s*:\s*(.*)$/);
+    if (!match) continue;
+    const key = match[1];
+    let value = match[2].trim();
+    value = value.replace(/^['"]|['"]$/g, '');
+    out[key] = value;
+  }
+  return out;
+}
+
+function firstMarkdownSentence(text) {
+  const body = String(text || '').replace(/^---\s*\n[\s\S]*?\n---/, '').trim();
+  const line = body.split(/\r?\n/).map((item) => item.trim().replace(/^#+\s*/, '')).find(Boolean);
+  return line || '';
+}
+
+function normalizeSkillCommandName(value) {
+  const raw = String(value || '').trim().split(':').pop() || '';
+  return raw
+    .replace(/[^A-Za-z0-9_-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 80)
+    .toLowerCase();
+}
+
+function sourceForSkillPath(file) {
+  const normalized = String(file || '');
+  if (normalized.includes(`${path.sep}.codex${path.sep}`)) return 'codex-local';
+  if (normalized.includes(`${path.sep}.claude${path.sep}`)) return 'claude-local';
+  if (normalized.includes(`${path.sep}.agents${path.sep}`)) return 'agents-local';
+  return 'local';
+}
+
 function runtimeModel(config, adapter, runtimeState = {}) {
   const fromRun = String(runtimeState.current_model || runtimeState.model || '').trim();
   if (fromRun) return fromRun;