@iinm/plain-agent 1.8.4 → 1.8.5

package/src/cliCompleter.mjs

@@ -0,0 +1,227 @@
+/**
+ * @import { ClaudeCodePlugin } from "./claudeCodePlugin.mjs"
+ */
+
+import { styleText } from "node:util";
+import { loadAgentRoles } from "./context/loadAgentRoles.mjs";
+import { loadPrompts } from "./context/loadPrompts.mjs";
+
+// Define available slash commands for tab completion
+export const SLASH_COMMANDS = [
+  { name: "/help", description: "Display this help message" },
+  { name: "/agents", description: "List available agent roles" },
+  {
+    name: "/agents:<id>",
+    description:
+      "Delegate to an agent with the given ID (e.g., /agents:code-simplifier)",
+  },
+  { name: "/prompts", description: "List available prompts" },
+  {
+    name: "/prompts:<id>",
+    description:
+      "Invoke a prompt with the given ID (e.g., /prompts:feature-dev)",
+  },
+  {
+    name: "/<id>",
+    description:
+      "Shortcut for prompts in the shortcuts/ directory (e.g., /commit)",
+  },
+  { name: "/paste", description: "Paste content from clipboard" },
+  {
+    name: "/resume",
+    description: "Resume conversation after an LLM provider error",
+  },
+  { name: "/dump", description: "Save current messages to a JSON file" },
+  { name: "/load", description: "Load messages from a JSON file" },
+  { name: "/cost", description: "Display session cost and token usage" },
+  {
+    name: "/compact",
+    description:
+      "Ask the agent to compact the context by reloading from a memory file",
+  },
+];
+
+/**
+ * @typedef {Object} CompletionCandidate
+ * @property {string} name
+ * @property {string} description
+ */
+
+/**
+ * Find candidates that match the line, prioritizing prefix matches.
+ * @param {(string | CompletionCandidate)[]} candidates
+ * @param {string} line
+ * @param {number} queryStartIndex
+ * @returns {(string | CompletionCandidate)[]}
+ */
+function findMatches(candidates, line, queryStartIndex) {
+  const query = line.slice(queryStartIndex);
+  const prefixMatches = [];
+  const partialMatches = [];
+
+  for (const candidate of candidates) {
+    const name = typeof candidate === "string" ? candidate : candidate.name;
+    if (name.startsWith(line)) {
+      prefixMatches.push(candidate);
+    } else if (
+      query.length > 0 &&
+      name.slice(queryStartIndex).includes(query)
+    ) {
+      partialMatches.push(candidate);
+    }
+  }
+
+  return [...prefixMatches, ...partialMatches];
+}
+
+/**
+ * Return the longest common prefix of the given strings.
+ * @param {string[]} strings
+ * @returns {string}
+ */
+function commonPrefix(strings) {
+  if (strings.length === 0) return "";
+  let prefix = strings[0];
+  for (let i = 1; i < strings.length; i++) {
+    while (!strings[i].startsWith(prefix)) {
+      prefix = prefix.slice(0, -1);
+    }
+  }
+  return prefix;
+}
+
+/**
+ * Display completion candidates and invoke the readline callback.
+ *
+ * Node.js readline normally requires two consecutive Tab presses to show the
+ * candidate list. This helper lets readline handle the common-prefix
+ * auto-completion first, then prints the candidate list on the next tick and
+ * redraws the prompt so the display stays clean.
+ *
+ * @param {import("node:readline").Interface} rl
+ * @param {(string | CompletionCandidate)[]} candidates
+ * @param {string} line
+ * @param {(err: Error | null, result: [string[], string]) => void} callback
+ */
+function showCompletions(rl, candidates, line, callback) {
+  const names = candidates.map((c) => (typeof c === "string" ? c : c.name));
+  if (candidates.length <= 1) {
+    callback(null, [names, line]);
+    return;
+  }
+  const prefix = commonPrefix(names);
+  if (prefix.length > line.length) {
+    // Let readline insert the common prefix.
+    callback(null, [[prefix], line]);
+  } else {
+    // Nothing new to insert.
+    callback(null, [[], line]);
+  }
+  // After readline finishes its own refresh, print the candidate list and
+  // redraw the prompt line.  We cannot use rl.prompt(true) because its
+  // internal _refreshLine clears everything below the prompt start, which
+  // erases the candidate list we just wrote.  Instead we manually re-output
+  // the prompt and current line content.
+  setTimeout(() => {
+    const maxLength = process.stdout.columns ?? 100;
+    const list = candidates
+      .map((c) => {
+        if (typeof c === "string") return c;
+        const nameText = c.name.padEnd(25);
+        const separator = " - ";
+        const descText = c.description;
+
+        // 画面幅に合わせて説明文をカット（色を付ける前に計算）
+        const availableWidth =
+          maxLength - nameText.length - separator.length - 3;
+        const displayDesc =
+          descText.length > availableWidth && availableWidth > 0
+            ? `${descText.slice(0, availableWidth)}...`
+            : descText;
+
+        const name = styleText("cyan", nameText);
+        const description = styleText("dim", displayDesc);
+        return `${name}${separator}${description}`;
+      })
+      .join("\r\n");
+    process.stdout.write(`\r\n${list}\r\n`);
+    process.stdout.write(`${rl.getPrompt()}${rl.line}`);
+  }, 0);
+}
+
+/**
+ * Create a completer function for readline.
+ *
+ * Because the readline.Interface instance (`cli`) is not available until after
+ * `readline.createInterface` returns, we accept a getter function so the
+ * completer can resolve the reference lazily at call time.
+ *
+ * @param {() => import("node:readline").Interface} getCliRef - A function that returns the readline Interface
+ * @param {ClaudeCodePlugin[] | undefined} claudeCodePlugins
+ * @returns {(line: string, callback: (err?: Error | null, result?: [string[], string]) => void) => void}
+ */
+export function createCompleter(getCliRef, claudeCodePlugins) {
+  return (line, callback) => {
+    (async () => {
+      try {
+        const cli = getCliRef();
+        const prompts = await loadPrompts(claudeCodePlugins);
+        const agentRoles = await loadAgentRoles(claudeCodePlugins);
+
+        if (line.startsWith("/agents:")) {
+          const prefix = "/agents:";
+          const candidates = Array.from(agentRoles.values()).map((a) => ({
+            name: `${prefix}${a.id}`,
+            description: a.description,
+          }));
+          const hits = findMatches(candidates, line, prefix.length);
+
+          showCompletions(cli, hits, line, callback);
+          return;
+        }
+
+        if (line.startsWith("/prompts:")) {
+          const prefix = "/prompts:";
+          const candidates = Array.from(prompts.values()).map((p) => ({
+            name: `${prefix}${p.id}`,
+            description: p.description,
+          }));
+          const hits = findMatches(candidates, line, prefix.length);
+
+          showCompletions(cli, hits, line, callback);
+          return;
+        }
+
+        if (line.startsWith("/")) {
+          const shortcuts = Array.from(prompts.values())
+            .filter((p) => p.isShortcut)
+            .map((p) => ({
+              name: `/${p.id}`,
+              description: p.description,
+            }));
+
+          const allCommands = [...SLASH_COMMANDS, ...shortcuts].filter(
+            (cmd) => {
+              const name = typeof cmd === "string" ? cmd : cmd.name;
+              return (
+                name !== "/<id>" &&
+                (name === "/agents:" || !name.startsWith("/agents:")) &&
+                (name === "/prompts:" || !name.startsWith("/prompts:"))
+              );
+            },
+          );
+
+          const hits = findMatches(allCommands, line, 1);
+
+          showCompletions(cli, hits, line, callback);
+          return;
+        }
+
+        callback(null, [[], line]);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        callback(error, [[], line]);
+      }
+    })();
+  };
+}

package/src/cliCost.mjs

@@ -0,0 +1,309 @@
+/**
+ * @import { UsageRecord } from "./usageStore.mjs"
+ */
+
+import { styleText } from "node:util";
+import * as usageStore from "./usageStore.mjs";
+
+/**
+ * @typedef {Object} CostPeriod
+ * @property {string} from - YYYY-MM-DD (inclusive, local date)
+ * @property {string} to - YYYY-MM-DD (inclusive, local date)
+ */
+
+/**
+ * @typedef {Object} DailyEntry
+ * @property {string} date - YYYY-MM-DD
+ * @property {number} totalCost
+ * @property {number} sessionCount
+ */
+
+/**
+ * @typedef {Object} CurrencyAggregation
+ * @property {string} currency
+ * @property {DailyEntry[]} daily - sorted by date ascending
+ * @property {number} totalCost
+ * @property {number} sessionCount
+ */
+
+/**
+ * @typedef {Object} CostReport
+ * @property {CostPeriod} period
+ * @property {CurrencyAggregation[]} byCurrency - sorted by currency
+ * @property {number} noPricingSessionCount - sessions without cost data
+ * @property {number} excludedOutOfRange - records dropped (out of period)
+ * @property {number} totalRecords - records considered (before filtering)
+ */
+
+/**
+ * Compute the default period: first day of current month (local) through today (local).
+ * @param {Date} [now]
+ * @returns {CostPeriod}
+ */
+export function defaultPeriod(now = new Date()) {
+  const y = now.getFullYear();
+  const m = now.getMonth();
+  const firstOfMonth = new Date(y, m, 1);
+  return {
+    from: formatLocalDate(firstOfMonth),
+    to: formatLocalDate(now),
+  };
+}
+
+/**
+ * Format a Date as YYYY-MM-DD in local time.
+ * @param {Date} date
+ * @returns {string}
+ */
+export function formatLocalDate(date) {
+  const y = date.getFullYear();
+  const m = `${date.getMonth() + 1}`.padStart(2, "0");
+  const d = `${date.getDate()}`.padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+
+/**
+ * Parse and validate a YYYY-MM-DD string, returning a Date at local midnight.
+ * @param {string} value
+ * @returns {Date}
+ */
+export function parseDateOnly(value) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!match) {
+    throw new Error(`Invalid date: "${value}" (expected YYYY-MM-DD)`);
+  }
+  const [, year, month, day] = match;
+  const y = Number(year);
+  const m = Number(month);
+  const d = Number(day);
+  const date = new Date(y, m - 1, d);
+  if (
+    date.getFullYear() !== y ||
+    date.getMonth() !== m - 1 ||
+    date.getDate() !== d
+  ) {
+    throw new Error(`Invalid date: "${value}"`);
+  }
+  return date;
+}
+
+/**
+ * Aggregate usage records into a cost report.
+ *
+ * @param {UsageRecord[]} records
+ * @param {CostPeriod} period
+ * @returns {CostReport}
+ */
+export function aggregateUsage(records, period) {
+  const fromDate = parseDateOnly(period.from);
+  const toDate = parseDateOnly(period.to);
+  if (fromDate.getTime() > toDate.getTime()) {
+    throw new Error(
+      `"from" (${period.from}) must be on or before "to" (${period.to}).`,
+    );
+  }
+
+  /** @type {Map<string, Map<string, DailyEntry>>} */
+  const byCurrency = new Map();
+  let noPricingSessionCount = 0;
+  let excludedOutOfRange = 0;
+
+  for (const record of records) {
+    if (record.timestamp == null) {
+      excludedOutOfRange++;
+      continue;
+    }
+    const recordedAt = new Date(record.timestamp);
+    if (Number.isNaN(recordedAt.getTime())) {
+      excludedOutOfRange++;
+      continue;
+    }
+    const localDate = formatLocalDate(recordedAt);
+    if (localDate < period.from || localDate > period.to) {
+      excludedOutOfRange++;
+      continue;
+    }
+    if (record.totalCost === null) {
+      noPricingSessionCount++;
+      continue;
+    }
+    if (!record.currency || typeof record.currency !== "string") {
+      excludedOutOfRange++;
+      continue;
+    }
+
+    const perDate = byCurrency.get(record.currency) ?? new Map();
+    byCurrency.set(record.currency, perDate);
+    const existing = perDate.get(localDate);
+    if (existing) {
+      existing.totalCost += record.totalCost;
+      existing.sessionCount += 1;
+    } else {
+      perDate.set(localDate, {
+        date: localDate,
+        totalCost: record.totalCost,
+        sessionCount: 1,
+      });
+    }
+  }
+
+  /** @type {CurrencyAggregation[]} */
+  const aggregations = [];
+  for (const [currency, perDate] of byCurrency) {
+    const daily = Array.from(perDate.values()).sort((a, b) =>
+      a.date.localeCompare(b.date),
+    );
+    let totalCost = 0;
+    let sessionCount = 0;
+    for (const entry of daily) {
+      totalCost += entry.totalCost;
+      sessionCount += entry.sessionCount;
+    }
+    aggregations.push({ currency, daily, totalCost, sessionCount });
+  }
+  aggregations.sort((a, b) => a.currency.localeCompare(b.currency));
+
+  return {
+    period,
+    byCurrency: aggregations,
+    noPricingSessionCount,
+    excludedOutOfRange,
+    totalRecords: records.length,
+  };
+}
+
+/**
+ * @param {number} count
+ * @returns {string}
+ */
+function formatSessions(count) {
+  return `${count} session${count === 1 ? "" : "s"}`;
+}
+
+/**
+ * Render a cost report as a human-readable string.
+ *
+ * @param {CostReport} report
+ * @param {{ color?: boolean }} [options]
+ * @returns {string}
+ */
+export function formatCostReport(report, options = {}) {
+  const color = options.color ?? true;
+  /** @param {string | string[]} _modifiers @param {string} text @returns {string} */
+  const plainStyle = (_modifiers, text) => text;
+  const style = color ? styleText : plainStyle;
+
+  const lines = [];
+  lines.push(
+    style("bold", `Period: ${report.period.from} to ${report.period.to}`),
+  );
+
+  if (report.byCurrency.length === 0) {
+    lines.push("");
+    lines.push(style("gray", "No usage recorded in this period."));
+    if (report.noPricingSessionCount > 0) {
+      lines.push(
+        style(
+          "gray",
+          `(${report.noPricingSessionCount} session(s) had no pricing configuration)`,
+        ),
+      );
+    }
+    return lines.join("\n");
+  }
+
+  for (const agg of report.byCurrency) {
+    lines.push("");
+    lines.push(style("bold", `Daily cost (${agg.currency}):`));
+    for (const entry of agg.daily) {
+      lines.push(
+        `  ${entry.date}   ${formatCost(entry.totalCost)} ${agg.currency}   (${formatSessions(entry.sessionCount)})`,
+      );
+    }
+    lines.push("");
+    lines.push(
+      style(
+        "bold",
+        `Total: ${formatCost(agg.totalCost)} ${agg.currency} (${formatSessions(agg.sessionCount)})`,
+      ),
+    );
+  }
+
+  if (report.noPricingSessionCount > 0) {
+    lines.push("");
+    lines.push(
+      style(
+        "gray",
+        `Note: ${report.noPricingSessionCount} session(s) had no pricing configuration and are excluded from totals.`,
+      ),
+    );
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Format a cost value with 4 decimals.
+ * @param {number} value
+ * @returns {string}
+ */
+function formatCost(value) {
+  return value.toFixed(4);
+}
+
+/**
+ * Run the `plain cost` subcommand.
+ *
+ * @param {{ from: string | null, to: string | null }} args
+ * @param {{ readUsageRecords?: typeof import("./usageStore.mjs").readUsageRecords }} [deps]
+ * @returns {Promise<number>} exit code
+ */
+export async function runCostCommand(args, deps = {}) {
+  let from;
+  let to;
+  try {
+    ({ from, to } = resolvePeriod(args));
+  } catch (err) {
+    if (err instanceof Error) {
+      console.error(`Error: ${err.message}`);
+    } else {
+      console.error("Error: invalid period arguments");
+    }
+    return 1;
+  }
+
+  const { records, skipped } = await (
+    deps.readUsageRecords ?? usageStore.readUsageRecords
+  )();
+  if (skipped.length > 0) {
+    const details = skipped
+      .slice(0, 3)
+      .map((s) => `line ${s.line}: ${s.reason}`)
+      .join(", ");
+    const ellipsis =
+      skipped.length > 3 ? `, and ${skipped.length - 3} more` : "";
+    console.error(
+      `Warning: skipped ${skipped.length} malformed line(s) in usage log (${details}${ellipsis}).`,
+    );
+  }
+
+  const report = aggregateUsage(records, { from, to });
+  console.log(formatCostReport(report));
+  return skipped.length > 0 ? 1 : 0;
+}
+
+/**
+ * Resolve a period from CLI arguments, falling back to the current month.
+ *
+ * @param {{ from: string | null, to: string | null }} args
+ * @returns {CostPeriod}
+ */
+export function resolvePeriod(args) {
+  const fallback = defaultPeriod();
+  const from = args.from ?? fallback.from;
+  const to = args.to ?? fallback.to;
+  // Validate format (throws on invalid input).
+  parseDateOnly(from);
+  parseDateOnly(to);
+  return { from, to };
+}