@llmist/cli 16.1.0 → 16.2.1

package/dist/cli.js

@@ -110,7 +110,7 @@ import { Command, InvalidArgumentError as InvalidArgumentError2 } from "commande
 // package.json
 var package_default = {
   name: "@llmist/cli",
-  version: "16.1.0",
+  version: "16.2.1",
   description: "CLI for llmist - run LLM agents from the command line",
   type: "module",
   main: "dist/cli.js",
@@ -167,7 +167,7 @@ var package_default = {
     node: ">=22.0.0"
   },
   dependencies: {
-    llmist: "^16.1.0",
+    llmist: "^16.2.1",
     "@unblessed/node": "^1.0.0-alpha.23",
     "diff-match-patch": "^1.0.5",
     chalk: "^5.6.2",
@@ -182,7 +182,7 @@ var package_default = {
     zod: "^4.1.12"
   },
   devDependencies: {
-    "@llmist/testing": "^16.1.0",
+    "@llmist/testing": "^16.2.1",
     "@types/diff": "^8.0.0",
     "@types/diff-match-patch": "^1.0.36",
     "@types/js-yaml": "^4.0.9",
@@ -211,15 +211,15 @@ var CONVERSION_TIMEOUT_MS = 3e4;
 var ffmpegCheckPromise = null;
 async function isFFmpegAvailable() {
   if (ffmpegCheckPromise !== null) return ffmpegCheckPromise;
-  ffmpegCheckPromise = new Promise((resolve3) => {
+  ffmpegCheckPromise = new Promise((resolve4) => {
     const proc = spawn("ffmpeg", ["-version"], { stdio: "ignore" });
-    proc.on("error", () => resolve3(false));
-    proc.on("close", (code) => resolve3(code === 0));
+    proc.on("error", () => resolve4(false));
+    proc.on("close", (code) => resolve4(code === 0));
   });
   return ffmpegCheckPromise;
 }
 async function convertToMp3(input, inputFormat, timeout = CONVERSION_TIMEOUT_MS) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     let timeoutId;
     const inputArgs = inputFormat === "pcm16" ? ["-f", "s16le", "-ar", "24000", "-ac", "1"] : ["-f", inputFormat];
     const proc = spawn(
@@ -244,15 +244,15 @@ async function convertToMp3(input, inputFormat, timeout = CONVERSION_TIMEOUT_MS)
     proc.stdout.on("data", (chunk) => chunks.push(chunk));
     proc.on("error", () => {
       clearTimeout(timeoutId);
-      resolve3(null);
+      resolve4(null);
     });
     proc.on("close", (code) => {
       clearTimeout(timeoutId);
-      resolve3(code === 0 ? Buffer.concat(chunks) : null);
+      resolve4(code === 0 ? Buffer.concat(chunks) : null);
     });
     timeoutId = setTimeout(() => {
       proc.kill();
-      resolve3(null);
+      resolve4(null);
     }, timeout);
     proc.stdin.on("error", () => {
     });
@@ -1413,6 +1413,48 @@ function resolveTemplatesInConfig(config, configPath) {
   return result;
 }
 
+// src/skills/config-types.ts
+var SKILLS_CONFIG_KEYS = /* @__PURE__ */ new Set(["sources", "overrides"]);
+var SKILL_OVERRIDE_KEYS = /* @__PURE__ */ new Set(["model", "enabled"]);
+function validateSkillsConfig(value, sectionName) {
+  if (typeof value !== "object" || value === null) {
+    throw new Error(`[${sectionName}] must be a table`);
+  }
+  const raw = value;
+  const result = {};
+  for (const [key, val] of Object.entries(raw)) {
+    if (key === "sources") {
+      if (!Array.isArray(val)) {
+        throw new Error(`[${sectionName}].sources must be an array`);
+      }
+      result.sources = val.map(String);
+    } else if (key === "overrides") {
+      if (typeof val !== "object" || val === null) {
+        throw new Error(`[${sectionName}].overrides must be a table`);
+      }
+      result.overrides = {};
+      for (const [skillName, override] of Object.entries(val)) {
+        if (typeof override !== "object" || override === null) {
+          throw new Error(`[${sectionName}].overrides.${skillName} must be a table`);
+        }
+        const overrideObj = override;
+        const skillOverride = {};
+        for (const [oKey, oVal] of Object.entries(overrideObj)) {
+          if (!SKILL_OVERRIDE_KEYS.has(oKey)) {
+            throw new Error(`[${sectionName}].overrides.${skillName}: unknown key "${oKey}"`);
+          }
+          if (oKey === "model") skillOverride.model = String(oVal);
+          if (oKey === "enabled") skillOverride.enabled = Boolean(oVal);
+        }
+        result.overrides[skillName] = skillOverride;
+      }
+    } else if (!SKILLS_CONFIG_KEYS.has(key)) {
+      throw new Error(`[${sectionName}]: unknown key "${key}"`);
+    }
+  }
+  return result;
+}
+
 // src/config.ts
 function getConfigPath() {
   return join(homedir2(), ".llmist", "cli.toml");
@@ -1443,6 +1485,8 @@ function validateConfig(raw, configPath) {
         result["rate-limits"] = validateRateLimitsConfig(value, key);
       } else if (key === "retry") {
         result.retry = validateRetryConfig(value, key);
+      } else if (key === "skills") {
+        result.skills = validateSkillsConfig(value, key);
       } else {
         result[key] = validateCustomConfig(value, key);
       }
@@ -1607,6 +1651,12 @@ var PathSandboxException = class extends Error {
 function validatePathIsWithinCwd(inputPath) {
   const cwd = process.cwd();
   const resolvedPath = path.resolve(cwd, inputPath);
+  let realCwd;
+  try {
+    realCwd = fs.realpathSync(cwd);
+  } catch {
+    realCwd = cwd;
+  }
   let finalPath;
   try {
     finalPath = fs.realpathSync(resolvedPath);
@@ -1618,8 +1668,8 @@ function validatePathIsWithinCwd(inputPath) {
       throw error;
     }
   }
-  const cwdWithSep = cwd + path.sep;
-  if (!finalPath.startsWith(cwdWithSep) && finalPath !== cwd) {
+  const cwdWithSep = realCwd + path.sep;
+  if (!finalPath.startsWith(cwdWithSep) && finalPath !== realCwd) {
     throw new PathSandboxException(inputPath, "Path is outside the current working directory");
   }
   return finalPath;
@@ -2670,9 +2720,9 @@ function spawn2(argv, options = {}) {
       options.stderr === "pipe" ? "pipe" : options.stderr ?? "ignore"
     ]
   });
-  const exited = new Promise((resolve3, reject) => {
+  const exited = new Promise((resolve4, reject) => {
     proc.on("exit", (code) => {
-      resolve3(code ?? 1);
+      resolve4(code ?? 1);
     });
     proc.on("error", (err) => {
       reject(err);
@@ -4858,14 +4908,14 @@ function configToCompleteOptions(config) {
     if (rl["tokens-per-minute"] !== void 0) result.rateLimitTpm = rl["tokens-per-minute"];
     if (rl["tokens-per-day"] !== void 0) result.rateLimitDaily = rl["tokens-per-day"];
     if (rl["safety-margin"] !== void 0) result.rateLimitSafetyMargin = rl["safety-margin"];
-    if (rl.enabled === false) result.noRateLimit = true;
+    if (rl.enabled === false) result.rateLimit = false;
   }
   if (config.retry) {
     const r = config.retry;
     if (r.retries !== void 0) result.maxRetries = r.retries;
     if (r["min-timeout"] !== void 0) result.retryMinTimeout = r["min-timeout"];
     if (r["max-timeout"] !== void 0) result.retryMaxTimeout = r["max-timeout"];
-    if (r.enabled === false) result.noRetry = true;
+    if (r.enabled === false) result.retry = false;
   }
   if (config.reasoning) {
     result.profileReasoning = config.reasoning;
@@ -4900,14 +4950,14 @@ function configToAgentOptions(config) {
     if (rl["tokens-per-minute"] !== void 0) result.rateLimitTpm = rl["tokens-per-minute"];
     if (rl["tokens-per-day"] !== void 0) result.rateLimitDaily = rl["tokens-per-day"];
     if (rl["safety-margin"] !== void 0) result.rateLimitSafetyMargin = rl["safety-margin"];
-    if (rl.enabled === false) result.noRateLimit = true;
+    if (rl.enabled === false) result.rateLimit = false;
   }
   if (config.retry) {
     const r = config.retry;
     if (r.retries !== void 0) result.maxRetries = r.retries;
     if (r["min-timeout"] !== void 0) result.retryMinTimeout = r["min-timeout"];
     if (r["max-timeout"] !== void 0) result.retryMaxTimeout = r["max-timeout"];
-    if (r.enabled === false) result.noRetry = true;
+    if (r.enabled === false) result.retry = false;
   }
   if (config.reasoning) {
     result.profileReasoning = config.reasoning;
@@ -4951,7 +5001,7 @@ function detectProvider(model) {
   }
 }
 function resolveRateLimitConfig(options, globalConfig, profileConfig, model) {
-  if (options.noRateLimit === true) {
+  if (options.rateLimit === false) {
     return { enabled: false, safetyMargin: 0.8 };
   }
   let resolved;
@@ -5076,12 +5126,82 @@ function resolveRetryConfig(options, globalConfig, profileConfig) {
   if (options.retryMaxTimeout !== void 0) {
     resolved.maxTimeout = options.retryMaxTimeout;
   }
-  if (options.noRetry === true) {
+  if (options.retry === false) {
     resolved.enabled = false;
   }
   return resolved;
 }
 
+// src/skills/skill-manager.ts
+import { homedir as homedir3 } from "os";
+import { join as join2, resolve as resolve3 } from "path";
+import { discoverSkills, loadSkillsFromDirectory } from "llmist";
+var CLISkillManager = class {
+  /**
+   * Load all skills from standard locations and configured sources.
+   *
+   * @param config - Skills configuration from cli.toml [skills] section
+   * @param projectDir - Project directory (cwd)
+   */
+  async loadAll(config, projectDir) {
+    const registry = discoverSkills({
+      projectDir: projectDir ?? process.cwd()
+    });
+    if (config?.sources) {
+      for (const source of config.sources) {
+        const resolvedSource = this.resolveSource(source);
+        const skills = loadSkillsFromDirectory(resolvedSource, {
+          type: "directory",
+          path: resolvedSource
+        });
+        registry.registerMany(skills);
+      }
+    }
+    if (config?.overrides) {
+      for (const [skillName, override] of Object.entries(config.overrides)) {
+        if (override.enabled === false) {
+          registry.remove(skillName);
+        }
+      }
+    }
+    return registry;
+  }
+  /**
+   * Resolve a source string to an absolute directory path.
+   */
+  resolveSource(source) {
+    if (source.startsWith("~")) {
+      return join2(homedir3(), source.slice(1));
+    }
+    return resolve3(source);
+  }
+};
+
+// src/skills/slash-handler.ts
+function parseSlashCommand(input, registry) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("/")) {
+    return { isSkillInvocation: false };
+  }
+  const match = trimmed.match(/^\/(\S+)(?:\s+(.*))?$/);
+  if (!match) {
+    return { isSkillInvocation: false };
+  }
+  const [, commandName, args] = match;
+  if (commandName === "skills") {
+    return { isSkillInvocation: true, isListCommand: true };
+  }
+  const skill = registry.get(commandName);
+  if (!skill || !skill.isUserInvocable) {
+    return { isSkillInvocation: false };
+  }
+  return {
+    isSkillInvocation: true,
+    skillName: commandName,
+    arguments: args?.trim()
+  };
+}
+
 // src/subagent-config.ts
 var INHERIT_MODEL = "inherit";
 function resolveSubagentConfig(subagentName, parentModel, profileConfig, globalConfig) {
@@ -7448,10 +7568,10 @@ var HintsBar = class {
 import { spawnSync as spawnSync2 } from "child_process";
 import { readFileSync as readFileSync4, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
 import { tmpdir } from "os";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 function openEditorSync(initialContent = "") {
   const editor = process.env.VISUAL || process.env.EDITOR || "vi";
-  const tmpFile = join2(tmpdir(), `llmist-input-${Date.now()}.txt`);
+  const tmpFile = join3(tmpdir(), `llmist-input-${Date.now()}.txt`);
   writeFileSync2(tmpFile, initialContent, "utf-8");
   try {
     const parts = editor.split(/\s+/);
@@ -7686,11 +7806,11 @@ var InputHandler = class {
    * @returns Promise that resolves with user's response
    */
   async waitForInput(question, gadgetName) {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       this.pendingInput = {
         question,
         gadgetName,
-        resolve: resolve3,
+        resolve: resolve4,
         reject
       };
       this.setActive();
@@ -7705,11 +7825,11 @@ var InputHandler = class {
    * @returns Promise that resolves with user's prompt
    */
   async waitForPrompt() {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       this.pendingInput = {
         question: "",
         gadgetName: "prompt",
-        resolve: resolve3,
+        resolve: resolve4,
         reject
       };
       this.setPendingPrompt();
@@ -7805,10 +7925,10 @@ var InputHandler = class {
       return;
     }
     if (this.pendingInput) {
-      const { resolve: resolve3 } = this.pendingInput;
+      const { resolve: resolve4 } = this.pendingInput;
       this.pendingInput = null;
       this.setIdle();
-      resolve3(value);
+      resolve4(value);
     } else if (this.midSessionHandler) {
       this.midSessionHandler(value);
       this.setIdle();
@@ -8266,7 +8386,7 @@ import { Box as Box3 } from "@unblessed/node";
 var MAX_PREVIEW_LINES = 10;
 var MAX_PARAM_VALUE_LENGTH = 60;
 function showApprovalDialog(screen, context) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const content = buildDialogContent(context);
     const dialog = new Box3({
       parent: screen,
@@ -8321,7 +8441,7 @@ function showApprovalDialog(screen, context) {
       if (response) {
         dialog.destroy();
         screen.render();
-        resolve3(response);
+        resolve4(response);
       }
     };
     dialog.on("keypress", handleKey);
@@ -8391,7 +8511,7 @@ var WHITE = "\x1B[37m";
 function showRawViewer(options) {
   let closeCallback = () => {
   };
-  const closed = new Promise((resolve3) => {
+  const closed = new Promise((resolve4) => {
     const {
       screen,
       mode,
@@ -8487,7 +8607,7 @@ ${error}`;
       helpBar.destroy();
       viewer.destroy();
       screen.render();
-      resolve3();
+      resolve4();
     };
     closeCallback = close;
     viewer.key(["escape", "q"], close);
@@ -9888,6 +10008,14 @@ async function executeAgent(promptArg, options, env, commandName) {
       registry.registerByClass(gadget);
     }
   }
+  let skillsConfig;
+  try {
+    const fullConfig = loadConfig();
+    skillsConfig = fullConfig.skills;
+  } catch {
+  }
+  const skillManager = new CLISkillManager();
+  const skillRegistry = await skillManager.loadAll(skillsConfig);
   let tui = null;
   if (useTUI) {
     tui = await TUIApp.create({
@@ -10121,6 +10249,9 @@ ${ctx.gadgetName} requires interactive approval. Enable TUI mode or adjust 'gadg
   if (options.temperature !== void 0) {
     builder.withTemperature(options.temperature);
   }
+  if (skillRegistry.size > 0) {
+    builder.withSkills(skillRegistry);
+  }
   if (options.reasoning === false) {
     builder.withoutReasoning();
   } else if (options.reasoning !== void 0 || options.reasoningBudget !== void 0) {
@@ -10197,6 +10328,29 @@ ${ctx.gadgetName} requires interactive approval. Enable TUI mode or adjust 'gadg
   );
   let currentAgent = null;
   const runAgentWithPrompt = async (userPrompt) => {
+    builder.clearPreActivatedSkills();
+    if (skillRegistry.size > 0 && userPrompt.startsWith("/")) {
+      const slashResult = parseSlashCommand(userPrompt, skillRegistry);
+      if (slashResult.isSkillInvocation) {
+        if (slashResult.isListCommand) {
+          const skills = skillRegistry.getUserInvocable();
+          const lines = skills.map((s) => `  /${s.name} \u2014 ${s.description}`);
+          const msg = skills.length > 0 ? `Available skills:
+${lines.join("\n")}` : "No skills available.";
+          if (tui) {
+            tui.showUserMessage(`/skills`);
+            tui.showUserMessage(msg);
+          } else {
+            env.stdout.write(`${msg}
+`);
+          }
+          return;
+        }
+        if (slashResult.skillName) {
+          builder.withSkill(slashResult.skillName, slashResult.arguments);
+        }
+      }
+    }
     if (tui) {
       tui.resetAbort();
       tui.startNewSession();
@@ -10321,11 +10475,11 @@ import {
 
 // src/llm-logging.ts
 import { mkdir, writeFile as writeFile2 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { formatCallNumber as formatCallNumber2, formatLlmRequest } from "llmist";
 async function writeLogFile(dir, filename, content) {
   await mkdir(dir, { recursive: true });
-  await writeFile2(join3(dir, filename), content, "utf-8");
+  await writeFile2(join4(dir, filename), content, "utf-8");
 }
 
 // src/complete-command.ts
@@ -10603,7 +10757,7 @@ System Prompt (${chars.toLocaleString()} chars, ${lines} lines):
 }
 
 // src/environment.ts
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import readline from "readline";
 import chalk7 from "chalk";
 import { createLogger, LLMist } from "llmist";
@@ -10626,7 +10780,7 @@ function createLoggerFactory(config, sessionLogDir) {
       }
     }
     if (sessionLogDir) {
-      const logFile = join4(sessionLogDir, "session.log.jsonl");
+      const logFile = join5(sessionLogDir, "session.log.jsonl");
       const originalLogFile = process.env.LLMIST_LOG_FILE;
       process.env.LLMIST_LOG_FILE = logFile;
       const logger = createLogger(options);
@@ -10645,7 +10799,7 @@ function createLoggerFactory(config, sessionLogDir) {
 }
 function createPromptFunction(stdin, stdout) {
   return (question) => {
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       const rl = readline.createInterface({
         input: stdin,
         output: stdout
@@ -10660,7 +10814,7 @@ function createPromptFunction(stdin, stdout) {
 `);
       rl.question(chalk7.green.bold("You: "), (answer) => {
         rl.close();
-        resolve3(answer);
+        resolve4(answer);
       });
     });
   };
@@ -11729,8 +11883,8 @@ function registerModelsCommand(program, env) {
 // src/session.ts
 import { existsSync as existsSync4 } from "fs";
 import { mkdir as mkdir2 } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join6 } from "path";
 
 // src/session-names.ts
 var ADJECTIVES = [
@@ -11865,16 +12019,16 @@ function generateSessionName() {
 
 // src/session.ts
 var currentSession;
-var SESSION_LOGS_BASE = join5(homedir3(), ".llmist", "logs");
+var SESSION_LOGS_BASE = join6(homedir4(), ".llmist", "logs");
 function findUniqueName(baseName) {
-  const baseDir = join5(SESSION_LOGS_BASE, baseName);
+  const baseDir = join6(SESSION_LOGS_BASE, baseName);
   if (!existsSync4(baseDir)) {
     return baseName;
   }
   let suffix = 2;
   while (suffix < 1e3) {
     const name = `${baseName}-${suffix}`;
-    const dir = join5(SESSION_LOGS_BASE, name);
+    const dir = join6(SESSION_LOGS_BASE, name);
     if (!existsSync4(dir)) {
       return name;
     }
@@ -11888,12 +12042,101 @@ async function initSession() {
   }
   const baseName = generateSessionName();
   const name = findUniqueName(baseName);
-  const logDir = join5(SESSION_LOGS_BASE, name);
+  const logDir = join6(SESSION_LOGS_BASE, name);
   await mkdir2(logDir, { recursive: true });
   currentSession = { name, logDir };
   return currentSession;
 }
 
+// src/skills/skill-command.ts
+function registerSkillCommand(program, env) {
+  const skillCmd = program.command("skill").description("Manage Agent Skills (SKILL.md)");
+  skillCmd.command("list").description("List available skills").action(async () => {
+    const config = safeLoadConfig();
+    const manager = new CLISkillManager();
+    const registry = await manager.loadAll(config?.skills);
+    const skills = registry.getAll();
+    if (skills.length === 0) {
+      env.stdout.write("No skills found.\n");
+      env.stdout.write(
+        "Add skills to ~/.llmist/skills/ or configure [skills].sources in ~/.llmist/cli.toml\n"
+      );
+      return;
+    }
+    env.stdout.write(`Found ${skills.length} skill(s):
+
+`);
+    for (const skill of skills) {
+      const flags = [];
+      if (!skill.isModelInvocable) flags.push("user-only");
+      if (!skill.isUserInvocable) flags.push("background");
+      if (skill.metadata.context === "fork") flags.push("fork");
+      if (skill.metadata.model) flags.push(`model:${skill.metadata.model}`);
+      const flagStr = flags.length > 0 ? ` [${flags.join(", ")}]` : "";
+      const desc = skill.description.length > 80 ? `${skill.description.slice(0, 77)}...` : skill.description;
+      env.stdout.write(`  /${skill.name}${flagStr}
+`);
+      env.stdout.write(`    ${desc}
+
+`);
+    }
+  });
+  skillCmd.command("info <name>").description("Show detailed skill information").action(async (name) => {
+    const config = safeLoadConfig();
+    const manager = new CLISkillManager();
+    const registry = await manager.loadAll(config?.skills);
+    const skill = registry.get(name);
+    if (!skill) {
+      env.stderr.write(`Skill not found: ${name}
+`);
+      env.stderr.write(`Available skills: ${registry.getNames().join(", ") || "(none)"}
+`);
+      process.exitCode = 1;
+      return;
+    }
+    env.stdout.write(`Skill: ${skill.name}
+`);
+    env.stdout.write(`Description: ${skill.description}
+`);
+    env.stdout.write(`Source: ${skill.sourcePath}
+`);
+    if (skill.metadata.model) env.stdout.write(`Model: ${skill.metadata.model}
+`);
+    if (skill.metadata.context) env.stdout.write(`Context: ${skill.metadata.context}
+`);
+    if (skill.metadata.agent) env.stdout.write(`Agent: ${skill.metadata.agent}
+`);
+    if (skill.metadata.allowedTools) {
+      env.stdout.write(`Allowed tools: ${skill.metadata.allowedTools.join(", ")}
+`);
+    }
+    if (skill.metadata.paths) {
+      env.stdout.write(`Paths: ${skill.metadata.paths.join(", ")}
+`);
+    }
+    const resources = skill.getResources();
+    if (resources.length > 0) {
+      env.stdout.write(`Resources: ${resources.length}
+`);
+      for (const r of resources) {
+        env.stdout.write(`  ${r.category}/${r.relativePath}
+`);
+      }
+    }
+    env.stdout.write("\n--- Instructions ---\n\n");
+    const instructions = await skill.getInstructions();
+    env.stdout.write(`${instructions}
+`);
+  });
+}
+function safeLoadConfig() {
+  try {
+    return loadConfig();
+  } catch {
+    return void 0;
+  }
+}
+
 // src/speech-command.ts
 import { writeFileSync as writeFileSync5 } from "fs";
 var DEFAULT_SPEECH_MODEL = "tts-1";
@@ -12005,6 +12248,7 @@ function createProgram(env, config) {
   registerVisionCommand(program, env);
   registerModelsCommand(program, env);
   registerGadgetCommand(program, env);
+  registerSkillCommand(program, env);
   registerInitCommand(program, env);
   registerConfigCommand(program, env, config);
   if (config) {