@iinm/plain-agent 1.8.2 → 1.8.4

package/src/context/loadPrompts.mjs

@@ -1,324 +0,0 @@
-/** @import { ClaudeCodePlugin } from "../claudeCodePlugin.mjs" */
-
-import { execFileSync } from "node:child_process";
-import crypto from "node:crypto";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { parse as parseYaml } from "yaml";
-import {
-  AGENT_CACHE_DIR,
-  AGENT_PROJECT_METADATA_DIR,
-  AGENT_ROOT,
-  AGENT_USER_CONFIG_DIR,
-} from "../env.mjs";
-
-/**
- * @typedef {Object} Prompt
- * @property {string} id
- * @property {string} description
- * @property {string} content
- * @property {string} filePath
- * @property {boolean} claudeOriginated
- * @property {string} [import]
- * @property {boolean} [userInvocable]
- * @property {boolean} [isShortcut]
- * @property {boolean} [isSkill]
- */
-
-/**
- * Load all prompts from the predefined directories.
- * @param {ClaudeCodePlugin[]} [claudeCodePlugins]
- * @returns {Promise<Map<string, Prompt>>}
- */
-export async function loadPrompts(claudeCodePlugins) {
-  /** @type {Array<{dir: string, idPrefix: string, only?: RegExp}>} */
-  const promptDirs = [
-    {
-      dir: path.resolve(AGENT_ROOT, "config", "prompts.predefined"),
-      idPrefix: "",
-    },
-    { dir: path.resolve(AGENT_USER_CONFIG_DIR, "prompts"), idPrefix: "" },
-    { dir: path.resolve(AGENT_PROJECT_METADATA_DIR, "prompts"), idPrefix: "" },
-    {
-      dir: path.resolve(process.cwd(), ".claude", "commands"),
-      idPrefix: "claude/commands:",
-    },
-    {
-      dir: path.resolve(process.cwd(), ".claude", "skills"),
-      idPrefix: "claude/skills:",
-    },
-  ];
-
-  // Add plugin directories if provided
-  if (claudeCodePlugins) {
-    for (const plugin of claudeCodePlugins) {
-      // Commands
-      promptDirs.push({
-        dir: path.join(plugin.path, "commands"),
-        idPrefix: `claude/${plugin.name}/commands:`,
-        only: plugin.only,
-      });
-
-      // Skills
-      promptDirs.push({
-        dir: path.join(plugin.path, "skills"),
-        idPrefix: `claude/${plugin.name}/skills:`,
-        only: plugin.only,
-      });
-    }
-  }
-
-  /** @type {Map<string, Prompt>} */
-  const prompts = new Map();
-
-  for (const { dir, idPrefix, only } of promptDirs) {
-    const files = await getMarkdownFiles(dir).catch((err) => {
-      if (err.code !== "ENOENT") {
-        console.warn(`Failed to list prompts in ${dir}:`, err);
-      }
-      return [];
-    });
-
-    for (const file of files) {
-      const fullPath = path.join(dir, file);
-      const content = await fs.readFile(fullPath, "utf-8").catch((err) => {
-        console.warn(`Failed to read prompt file ${fullPath}:`, err);
-        return null;
-      });
-
-      if (content === null) continue;
-
-      // Filter by only pattern if specified
-      if (only && !only.test(file)) {
-        continue;
-      }
-
-      //  Ignore all files in the skills/ directory except for SKILL.md.
-      if (fullPath.match(/\/skills\//) && !file.endsWith("/SKILL.md")) {
-        continue;
-      }
-
-      let prompt = parsePrompt(file, content, fullPath, idPrefix);
-      if (prompt.import) {
-        prompt = await mergeRemotePrompt(prompt, file, fullPath);
-      }
-
-      if (prompt.userInvocable === false) {
-        continue;
-      }
-
-      prompts.set(prompt.id, prompt);
-    }
-  }
-
-  return prompts;
-}
-
-/**
- * Merges a remote prompt into a local prompt if an import URL is provided.
- * @param {Prompt} localPrompt
- * @param {string} relativePath
- * @param {string} fullPath
- * @returns {Promise<Prompt>}
- */
-async function mergeRemotePrompt(localPrompt, relativePath, fullPath) {
-  const importUrl = localPrompt.import;
-  if (!importUrl) {
-    return localPrompt;
-  }
-
-  const fetchedContent = await fetchAndCachePrompt(importUrl).catch((err) => {
-    console.warn(`Failed to fetch prompt from ${importUrl}:`, err);
-    return null;
-  });
-
-  if (!fetchedContent) {
-    return localPrompt;
-  }
-
-  const remotePrompt = parsePrompt(relativePath, fetchedContent, fullPath);
-
-  return {
-    ...remotePrompt,
-    ...localPrompt, // Local overrides
-    content: `${remotePrompt.content}\n\n---\n\n${localPrompt.content}`.trim(),
-    description: localPrompt.description || remotePrompt.description || "",
-  };
-}
-
-/**
- * Fetch a prompt from a URL and cache it.
- * @param {string} url
- * @returns {Promise<string>}
- */
-async function fetchAndCachePrompt(url) {
-  const hash = crypto.createHash("sha256").update(url).digest("hex");
-  const cacheDir = path.join(AGENT_CACHE_DIR, "prompts");
-  const cachePath = path.join(cacheDir, hash);
-
-  const cachedContent = await fs.readFile(cachePath, "utf-8").catch(() => null);
-  if (cachedContent !== null) {
-    return cachedContent;
-  }
-
-  const fetchedContent = await fetchContent(url);
-
-  // Attempt to cache, but don't block or fail on errors
-  fs.mkdir(cacheDir, { recursive: true })
-    .then(() => fs.writeFile(cachePath, fetchedContent, "utf-8"))
-    .catch((err) => {
-      console.warn(`Failed to write cache for ${url}:`, err);
-    });
-
-  return fetchedContent;
-}
-
-/**
- * Fetch content from a URL.
- * @param {string} url
- * @returns {Promise<string>}
- */
-async function fetchContent(url) {
-  const githubMatch = url.match(
-    /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/blob\/([^/]+)\/(.+)$/,
-  );
-
-  if (githubMatch) {
-    const [, owner, repo, ref, path] = githubMatch;
-    const apiUrl = `repos/${owner}/${repo}/contents/${path}?ref=${ref}`;
-    try {
-      return execFileSync(
-        "gh",
-        ["api", "-H", "Accept: application/vnd.github.v3.raw", apiUrl],
-        { encoding: "utf-8" },
-      );
-    } catch (err) {
-      throw new Error(`Failed to fetch from GitHub via gh CLI: ${err}`);
-    }
-  }
-
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(
-      `Failed to fetch prompt from ${url}: ${response.status} ${response.statusText}`,
-    );
-  }
-  return response.text();
-}
-
-/**
- * Recursively get all markdown files in a directory.
- * @param {string} dir
- * @param {string} [baseDir]
- * @returns {Promise<string[]>}
- */
-async function getMarkdownFiles(dir, baseDir = dir) {
-  const entries = await fs.readdir(dir, { withFileTypes: true });
-  const files = [];
-
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    let isDirectory = entry.isDirectory();
-    let isFile = entry.isFile();
-
-    if (entry.isSymbolicLink()) {
-      const stat = await fs.stat(fullPath).catch(() => null);
-      if (!stat) continue;
-      isDirectory = stat.isDirectory();
-      isFile = stat.isFile();
-    }
-
-    if (isDirectory) {
-      files.push(...(await getMarkdownFiles(fullPath, baseDir)));
-    } else if (isFile && entry.name.endsWith(".md")) {
-      files.push(path.relative(baseDir, fullPath));
-    }
-  }
-
-  return files;
-}
-
-/**
- * Parse a prompt file content.
- * @param {string} relativePath
- * @param {string} fileContent
- * @param {string} fullPath
- * @param {string} [idPrefix=""]
- * @returns {Prompt}
- */
-function parsePrompt(relativePath, fileContent, fullPath, idPrefix = "") {
-  const rawId = relativePath.replace(/\/SKILL\.md$/, "").replace(/\.md$/, "");
-  const isSkill = relativePath.endsWith("SKILL.md");
-  const isShortcut = rawId.startsWith("shortcuts/");
-  const id = isShortcut
-    ? idPrefix + rawId.replace(/^shortcuts\//, "")
-    : idPrefix + rawId;
-  const claudeOriginated = idPrefix.startsWith("claude");
-
-  // Match YAML frontmatter
-  const match = fileContent.match(
-    /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/,
-  );
-
-  if (!match) {
-    return {
-      id,
-      description: "",
-      content: fileContent.trim(),
-      filePath: fullPath,
-      claudeOriginated,
-      isShortcut,
-      isSkill,
-    };
-  }
-
-  const content = match[2].trim();
-
-  /** @type {{description?:string; import?:string; "user-invocable"?:boolean}} */
-  let frontmatter;
-  try {
-    frontmatter =
-      /** @type {{description?:string; import?:string; "user-invocable"?:boolean}} */ (
-        parseYaml(match[1])
-      );
-  } catch (_err) {
-    return {
-      id,
-      description: parseFrontmatterField(match[1], "description") ?? "",
-      content,
-      filePath: fullPath,
-      claudeOriginated,
-      import: parseFrontmatterField(match[1], "import"),
-      userInvocable:
-        parseFrontmatterField(match[1], "user-invocable") === "true" ||
-        undefined,
-      isShortcut,
-      isSkill,
-    };
-  }
-  const userInvocable = frontmatter["user-invocable"];
-
-  return {
-    id,
-    description: frontmatter.description ?? "",
-    content,
-    filePath: fullPath,
-    claudeOriginated,
-    import: frontmatter.import,
-    userInvocable: userInvocable ?? undefined,
-    isShortcut,
-    isSkill: relativePath.endsWith("SKILL.md"),
-  };
-}
-
-/**
- * Parse a field from YAML frontmatter.
- * @param {string} frontmatter
- * @param {string} field
- * @returns {string | undefined}
- */
-function parseFrontmatterField(frontmatter, field) {
-  const regex = new RegExp(`^${field}:\\s*(.*)$`, "m");
-  const match = frontmatter.match(regex);
-  return match ? match[1].trim() : undefined;
-}

package/src/context/loadUserMessageContext.mjs

@@ -1,147 +0,0 @@
-/**
- * @import { MessageContentText, MessageContentImage } from "../model";
- */
-
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { styleText } from "node:util";
-import { noThrow } from "../utils/noThrow.mjs";
-import { parseFileRange } from "../utils/parseFileRange.mjs";
-import { readFileRange } from "../utils/readFileRange.mjs";
-
-/** @type {ReadonlyMap<string, string>} */
-const IMAGE_MIME_TYPES = new Map([
-  [".png", "image/png"],
-  [".jpg", "image/jpeg"],
-  [".jpeg", "image/jpeg"],
-  [".gif", "image/gif"],
-  [".webp", "image/webp"],
-]);
-
-/**
- * @param {string} message
- * @returns {Promise<(MessageContentText | MessageContentImage)[]>}
- */
-export async function loadUserMessageContext(message) {
-  const workingDir = process.cwd();
-
-  /** @type {string[]} */
-  const text = [];
-  /** @type {string[]} */
-  const contexts = [];
-  /** @type {MessageContentImage[]} */
-  const images = [];
-
-  let cursor = 0;
-  for (const match of message.matchAll(
-    /(^|\s)@(?:'([^']+)'|((?:\\ |[^\s])+))/g,
-  )) {
-    if (cursor < match.index) {
-      text.push(message.slice(cursor, match.index));
-    }
-    cursor = match.index + match[0].length;
-    const [entireMatch, leading, quoted, escaped] = match;
-    const reference = quoted ?? escaped.replace(/\\ /g, " ");
-
-    const ext = path.extname(reference).toLowerCase();
-    if (IMAGE_MIME_TYPES.has(ext)) {
-      const imageContent = await loadImageContent(reference);
-      if (imageContent instanceof Error) {
-        warn(`Failed to load image from ${reference}: ${imageContent.message}`);
-        text.push(entireMatch);
-        continue;
-      }
-      images.push(imageContent);
-      text.push(`${leading}[Image #${images.length}:${reference}]`);
-      continue;
-    }
-
-    const contextSnippet = await loadContextSnippet(reference, workingDir);
-    if (contextSnippet) {
-      contexts.push(contextSnippet);
-    }
-    text.push(entireMatch);
-  }
-
-  if (cursor < message.length) {
-    text.push(message.slice(cursor));
-  }
-
-  return [
-    { type: "text", text: [text.join(""), ...contexts].join("\n\n") },
-    ...images,
-  ];
-}
-
-/**
- * @param {string} reference
- * @param {string} workingDir
- * @returns {Promise<string | null>}
- */
-async function loadContextSnippet(reference, workingDir) {
-  const fileRange = parseFileRange(reference);
-  if (fileRange instanceof Error) {
-    warn(`Failed to parse context reference ${reference}: ${fileRange}`);
-    return null;
-  }
-
-  const absolutePath = path.resolve(fileRange.filePath);
-  const relativePath = path.relative(workingDir, absolutePath);
-  if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
-    warn(
-      `Refusing to load context from outside working directory: ${absolutePath}`,
-    );
-    return null;
-  }
-
-  const fileContent = await readFileRange(fileRange);
-  if (fileContent instanceof Error) {
-    warn(`Failed to load context from ${reference}: ${fileContent}`);
-    return null;
-  }
-
-  return [`<context location="${reference}">`, fileContent, "</context>"].join(
-    "\n",
-  );
-}
-
-/**
- * @param {string} imagePath
- * @returns {Promise<MessageContentImage | Error>}
- */
-async function loadImageContent(imagePath) {
-  const absolutePath = path.resolve(imagePath);
-
-  return await noThrow(async () => {
-    const data = await readFile(absolutePath);
-    return {
-      type: "image",
-      data: data.toString("base64"),
-      mimeType: inferMimeType(absolutePath),
-    };
-  });
-}
-
-/**
- * @param {string} filePath
- * @returns {string}
- */
-function inferMimeType(filePath) {
-  const extension = path.extname(filePath).toLowerCase();
-  const mimeType = IMAGE_MIME_TYPES.get(extension);
-  if (!mimeType) {
-    throw new Error(
-      `Unsupported image extension: ${extension} (file: ${filePath})`,
-    );
-  }
-
-  return mimeType;
-}
-
-/**
- * @param {string} message
- * @returns {void}
- */
-function warn(message) {
-  console.warn(styleText("yellow", message));
-}

package/src/costTracker.mjs

@@ -1,210 +0,0 @@
-/**
- * @import { ProviderTokenUsage } from "./model"
- */
-
-/**
- * @typedef {Object} TokenBreakdown
- * @property {number} tokens - Token count
- * @property {number | undefined} cost - Cost (undefined if no pricing)
- */
-
-/**
- * @typedef {Object} CostSummary
- * @property {string} currency - Currency code (e.g., "USD")
- * @property {string} unit - Unit size (e.g., "1M")
- * @property {Record<string, TokenBreakdown>} breakdown - Token breakdown
- * @property {number | undefined} totalCost - Total cost (undefined if no pricing)
- */
-
-/**
- * @typedef {Object} CostConfig
- * @property {string} currency
- * @property {string} unit
- * @property {Record<string, number>} costs
- */
-
-/**
- * @typedef {Object} CostTracker
- * @property {(usage: ProviderTokenUsage) => void} recordUsage - Record token usage
- * @property {() => Record<string, number>} getAggregatedUsage - Get aggregated usage
- * @property {() => CostSummary} calculateCost - Calculate cost summary
- * @property {() => boolean} hasUsage - Check if any usage recorded
- */
-
-/**
- * Validate a cost configuration object at runtime.
- * @param {unknown} config
- */
-function validateCostConfig(config) {
-  if (config === undefined) return;
-  if (typeof config !== "object" || config === null) {
-    throw new TypeError("CostConfig must be an object");
-  }
-  const c = /** @type {Record<string, unknown>} */ (config);
-  if (typeof c.currency !== "string") {
-    throw new TypeError("CostConfig.currency must be a string");
-  }
-  if (typeof c.unit !== "string") {
-    throw new TypeError("CostConfig.unit must be a string");
-  }
-  if (typeof c.costs !== "object" || c.costs === null) {
-    throw new TypeError("CostConfig.costs must be an object");
-  }
-  for (const [key, value] of Object.entries(
-    /** @type {Record<string, unknown>} */ (c.costs),
-  )) {
-    if (typeof value !== "number") {
-      throw new TypeError(
-        `CostConfig.costs["${key}"] must be a number, got ${typeof value}`,
-      );
-    }
-  }
-}
-
-/**
- * Create a cost tracker for session token usage
- * @param {CostConfig} [costConfig] - Optional cost configuration
- * @returns {CostTracker}
- */
-export function createCostTracker(costConfig) {
-  validateCostConfig(costConfig);
-
-  /** @type {ProviderTokenUsage[]} */
-  const usageHistory = [];
-
-  /**
-   * Record token usage from a provider.
-   * Throws when usage is not a non-null object.
-   * @param {ProviderTokenUsage} usage
-   * @throws {TypeError} when usage is null, undefined, or not an object
-   */
-  function recordUsage(usage) {
-    if (typeof usage !== "object" || usage === null) {
-      throw new TypeError("usage must be a non-null object");
-    }
-    usageHistory.push(usage);
-  }
-
-  /**
-   * Get aggregated token usage
-   * @returns {Record<string, number>}
-   */
-  function getAggregatedUsage() {
-    return aggregateTokens(usageHistory);
-  }
-
-  /**
-   * Calculate cost summary
-   * @returns {CostSummary}
-   */
-  function calculateCost() {
-    const aggregated = aggregateTokens(usageHistory);
-    return calculateCostFromConfig(aggregated, costConfig);
-  }
-
-  /**
-   * Check if any usage recorded
-   * @returns {boolean}
-   */
-  function hasUsage() {
-    return usageHistory.length > 0;
-  }
-
-  return Object.freeze({
-    recordUsage,
-    getAggregatedUsage,
-    calculateCost,
-    hasUsage,
-  });
-}
-
-/**
- * Aggregate token usage history by key
- * @param {ProviderTokenUsage[]} usageHistory
- * @returns {Record<string, number>}
- */
-function aggregateTokens(usageHistory) {
-  /** @type {Record<string, number>} */
-  const aggregated = {};
-
-  for (const usage of usageHistory) {
-    recursivelySumValues(usage, [], aggregated);
-  }
-
-  return aggregated;
-}
-
-/**
- * Recursively sum numeric values in token usage
- * @param {ProviderTokenUsage} obj
- * @param {string[]} path
- * @param {Record<string, number>} result
- */
-function recursivelySumValues(obj, path, result) {
-  for (const [key, value] of Object.entries(obj)) {
-    const currentPath = [...path, key];
-    const pathStr = currentPath.join(".");
-
-    if (typeof value === "number") {
-      result[pathStr] = (result[pathStr] || 0) + value;
-    } else if (
-      typeof value === "object" &&
-      value !== null &&
-      !Array.isArray(value)
-    ) {
-      recursivelySumValues(value, currentPath, result);
-    }
-  }
-}
-
-/**
- * Calculate cost from aggregated tokens and config
- * @param {Record<string, number>} aggregated
- * @param {CostConfig | undefined} config
- * @returns {CostSummary}
- */
-function calculateCostFromConfig(aggregated, config) {
-  /** @type {Record<string, TokenBreakdown>} */
-  const breakdown = {};
-  let totalCost = 0;
-
-  for (const [key, tokens] of Object.entries(aggregated)) {
-    breakdown[key] = Object.freeze({ tokens, cost: undefined });
-
-    if (!config?.costs?.[key]) {
-      continue;
-    }
-
-    const costValue = config.costs[key];
-    const unitSize = parseUnit(config.unit);
-
-    if (typeof costValue !== "number") {
-      throw new TypeError(
-        `config.costs["${key}"] must be a number, got ${typeof costValue}`,
-      );
-    }
-
-    const cost = (tokens * costValue) / unitSize;
-    breakdown[key] = Object.freeze({ tokens, cost });
-    totalCost += cost;
-  }
-
-  return Object.freeze({
-    currency: config?.currency ?? "USD",
-    unit: config?.unit ?? "1M",
-    breakdown,
-    totalCost: config?.costs ? totalCost : undefined,
-  });
-}
-
-/**
- * Parse unit string to number.
- * @param {string} unit
- * @returns {number}
- * @throws {Error} when the unit is not recognized
- */
-function parseUnit(unit) {
-  if (unit === "1M") return 1_000_000;
-  if (unit === "1K") return 1_000;
-  throw new Error(`Unknown cost unit: "${unit}"`);
-}