autohand-cli 0.8.2 → 0.8.3

package/dist/chunk-3WVJEL7K.cjs

@@ -0,0 +1,568 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/commands/repeat.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var metadata = {
+  command: "/repeat",
+  description: "Schedule a recurring prompt at a fixed interval",
+  implemented: true,
+  subcommands: [
+    { name: "list", description: "Show all active recurring jobs" },
+    { name: "cancel", description: "Cancel a recurring job by ID" },
+    { name: "help", description: "Show usage and examples" }
+  ]
+};
+var DEFAULT_INTERVAL = "5m";
+var LEADING_INTERVAL_RE = /^\d+[smhd]$/;
+var LEADING_EVERY_RE = /^every\s+(\d+)?\s*(s(?:ec(?:ond)?s?)?|m(?:in(?:ute)?s?)?|h(?:(?:ou)?rs?)?|d(?:ays?)?)\s+/i;
+var TRAILING_EVERY_RE = /\s+every\s+(\d+)?\s*(s(?:ec(?:ond)?s?)?|m(?:in(?:ute)?s?)?|h(?:(?:ou)?rs?)?|d(?:ays?)?)$/i;
+var MIDDLE_EVERY_RE = /\s+every\s+(\d+)?\s*(s(?:ec(?:ond)?s?)?|m(?:in(?:ute)?s?)?|h(?:(?:ou)?rs?)?|d(?:ays?)?)\s+/i;
+var UNIT_MAP = {
+  s: "s",
+  sec: "s",
+  secs: "s",
+  second: "s",
+  seconds: "s",
+  m: "m",
+  min: "m",
+  mins: "m",
+  minute: "m",
+  minutes: "m",
+  h: "h",
+  hr: "h",
+  hrs: "h",
+  hour: "h",
+  hours: "h",
+  d: "d",
+  day: "d",
+  days: "d"
+};
+function parseInput(raw) {
+  const trimmed = raw.trim();
+  const parts = trimmed.split(/\s+/);
+  if (parts.length >= 1 && LEADING_INTERVAL_RE.test(parts[0])) {
+    return {
+      interval: parts[0],
+      prompt: parts.slice(1).join(" "),
+      explicit: true
+    };
+  }
+  const leadingMatch = trimmed.match(LEADING_EVERY_RE);
+  if (leadingMatch) {
+    const n = leadingMatch[1] || "1";
+    const rawUnit = leadingMatch[2].toLowerCase();
+    const unit = UNIT_MAP[rawUnit];
+    if (unit) {
+      return {
+        interval: `${n}${unit}`,
+        prompt: trimmed.slice(leadingMatch[0].length).trim(),
+        explicit: true
+      };
+    }
+  }
+  const trailingMatch = trimmed.match(TRAILING_EVERY_RE);
+  if (trailingMatch) {
+    const n = trailingMatch[1] || "1";
+    const rawUnit = trailingMatch[2].toLowerCase();
+    const unit = UNIT_MAP[rawUnit];
+    if (unit) {
+      return {
+        interval: `${n}${unit}`,
+        prompt: trimmed.slice(0, trailingMatch.index).trim(),
+        explicit: true
+      };
+    }
+  }
+  const middleMatch = trimmed.match(MIDDLE_EVERY_RE);
+  if (middleMatch) {
+    const n = middleMatch[1] || "1";
+    const rawUnit = middleMatch[2].toLowerCase();
+    const unit = UNIT_MAP[rawUnit];
+    if (unit) {
+      const before = trimmed.slice(0, middleMatch.index).trim();
+      const after = trimmed.slice(middleMatch.index + middleMatch[0].length).trim();
+      const prompt = [before, after].filter(Boolean).join(" ");
+      return {
+        interval: `${n}${unit}`,
+        prompt,
+        explicit: true
+      };
+    }
+  }
+  return {
+    interval: DEFAULT_INTERVAL,
+    prompt: trimmed,
+    explicit: false
+  };
+}
+function intervalToCron(interval) {
+  const match = interval.match(/^(\d+)([smhd])$/);
+  if (!match) {
+    throw new Error(`Invalid interval format: ${interval}`);
+  }
+  let n = parseInt(match[1], 10);
+  const unit = match[2];
+  if (unit === "s") {
+    const minutes = Math.max(1, Math.ceil(n / 60));
+    const roundedNote = `Rounded ${n}s up to ${minutes}m (cron minimum granularity is 1 minute).`;
+    return intervalToCronMinutes(minutes, roundedNote);
+  }
+  if (unit === "m") {
+    return intervalToCronMinutes(n);
+  }
+  if (unit === "h") {
+    if (n <= 0) throw new Error("Hour interval must be >= 1");
+    if (n > 23) {
+      const days = Math.round(n / 24);
+      const roundedNote2 = `Rounded ${n}h to ${days}d (${days * 24}h).`;
+      return {
+        cronExpression: `0 0 */${days} * *`,
+        intervalMs: days * 24 * 60 * 60 * 1e3,
+        humanReadable: `every ${days} day${days > 1 ? "s" : ""} at midnight`,
+        roundedNote: roundedNote2
+      };
+    }
+    let roundedNote;
+    if (24 % n !== 0) {
+      const clean = nearestDivisor(n, 24);
+      roundedNote = `${n}h doesn't divide 24 evenly; rounded to every ${clean}h.`;
+      n = clean;
+    }
+    return {
+      cronExpression: `0 */${n} * * *`,
+      intervalMs: n * 60 * 60 * 1e3,
+      humanReadable: `every ${n} hour${n > 1 ? "s" : ""}`,
+      roundedNote
+    };
+  }
+  if (n <= 0) throw new Error("Day interval must be >= 1");
+  return {
+    cronExpression: `0 0 */${n} * *`,
+    intervalMs: n * 24 * 60 * 60 * 1e3,
+    humanReadable: `every ${n} day${n > 1 ? "s" : ""} at midnight`
+  };
+}
+function intervalToCronMinutes(n, roundedNote) {
+  if (n <= 0) throw new Error("Minute interval must be >= 1");
+  if (n < 60) {
+    let note2 = roundedNote;
+    if (60 % n !== 0) {
+      const clean = nearestDivisor(n, 60);
+      note2 = (note2 ? note2 + " " : "") + `${n}m doesn't divide 60 evenly; rounded to every ${clean}m.`;
+      n = clean;
+    }
+    return {
+      cronExpression: `*/${n} * * * *`,
+      intervalMs: n * 60 * 1e3,
+      humanReadable: `every ${n} minute${n > 1 ? "s" : ""}`,
+      roundedNote: note2
+    };
+  }
+  let hours = Math.round(n / 60);
+  if (hours <= 0) hours = 1;
+  let note = roundedNote;
+  if (24 % hours !== 0) {
+    const clean = nearestDivisor(hours, 24);
+    note = (note ? note + " " : "") + `${n}m rounds to ${hours}h which doesn't divide 24; using every ${clean}h.`;
+    hours = clean;
+  } else if (n !== hours * 60) {
+    note = (note ? note + " " : "") + `Rounded ${n}m to ${hours}h.`;
+  }
+  return {
+    cronExpression: `0 */${hours} * * *`,
+    intervalMs: hours * 60 * 60 * 1e3,
+    humanReadable: `every ${hours} hour${hours > 1 ? "s" : ""}`,
+    roundedNote: note
+  };
+}
+function nearestDivisor(n, max) {
+  let best = 1;
+  for (let d = 1; d <= max; d++) {
+    if (max % d === 0 && Math.abs(d - n) < Math.abs(best - n)) {
+      best = d;
+    }
+  }
+  return best;
+}
+function shorthandToMs(shorthand) {
+  const match = shorthand.match(/^(\d+)([smhd])$/);
+  if (!match) return 3 * 24 * 60 * 60 * 1e3;
+  const n = parseInt(match[1], 10);
+  const unit = match[2];
+  switch (unit) {
+    case "s":
+      return n * 1e3;
+    case "m":
+      return n * 60 * 1e3;
+    case "h":
+      return n * 60 * 60 * 1e3;
+    case "d":
+      return n * 24 * 60 * 60 * 1e3;
+    default:
+      return 3 * 24 * 60 * 60 * 1e3;
+  }
+}
+function shorthandToHuman(shorthand) {
+  const match = shorthand.match(/^(\d+)([smhd])$/);
+  if (!match) return shorthand;
+  const n = parseInt(match[1], 10);
+  const unit = match[2];
+  const names = { s: "second", m: "minute", h: "hour", d: "day" };
+  const name = _nullishCoalesce(names[unit], () => ( unit));
+  return `${n} ${name}${n !== 1 ? "s" : ""}`;
+}
+var REPEAT_SYSTEM_PROMPT = `# Goal
+Extract a recurring schedule from natural language. Return the interval and the actionable task as JSON.
+
+# Persona
+You are a scheduling intent parser for a CLI coding agent. You receive raw user input and decompose it into exactly two parts: how often (interval) and what to do (prompt). You are precise, never hallucinate fields, and always return valid JSON.
+
+# Action
+Return ONLY a JSON object with these fields:
+- "interval": (required) shorthand format <number><unit> where unit is s, m, h, or d (e.g. "5m", "2h", "1d")
+- "prompt": (required) the actionable task, cleaned of all scheduling language and conversational filler
+- "maxRuns": (optional, integer) if the user specifies a finite execution count, include it. Omit if unlimited.
+- "expiresIn": (optional, shorthand like interval) if the user specifies a custom duration/deadline, include it. Omit to use the default 3-day expiry.
+
+## Interval extraction rules (in priority order)
+
+1. Explicit frequency \u2192 convert directly:
+   "every 5 minutes" \u2192 "5m" | "every 2 hours" \u2192 "2h" | "every 30 seconds" \u2192 "30s" | "every 3 days" \u2192 "3d"
+
+2. Named frequencies \u2192 map to interval:
+   "every minute" \u2192 "1m" | "every hour" \u2192 "1h" | "every day" \u2192 "1d" | "every second" \u2192 "1s"
+   "hourly" \u2192 "1h" | "daily" \u2192 "1d" | "every half hour" \u2192 "30m" | "every quarter hour" \u2192 "15m"
+
+3. Multiplicative expressions \u2192 compute interval:
+   "twice an hour" \u2192 "30m" | "three times an hour" \u2192 "20m" | "once an hour" \u2192 "1h"
+   "twice a day" \u2192 "12h" | "three times a day" \u2192 "8h" | "once a day" \u2192 "1d"
+
+4. Colloquial / vague frequencies \u2192 best-effort:
+   "every couple of minutes" \u2192 "2m" | "every few minutes" \u2192 "5m" | "every other hour" \u2192 "2h"
+   "continuously" / "nonstop" / "constantly" \u2192 "1m" | "periodically" / "frequently" / "regularly" \u2192 "5m"
+
+5. Implied repetition words are scheduling intent \u2014 strip them from the prompt:
+   "keep running tests" \u2192 interval "1m", prompt "run tests"
+   "keep checking the build" \u2192 interval "1m", prompt "check the build"
+   "repeatedly lint the codebase" \u2192 interval "5m", prompt "lint the codebase"
+
+6. Unsupported time scales \u2192 clamp to "1d":
+   "weekly" / "monthly" / "every week" / "every month" \u2192 "1d"
+
+7. No frequency detected at all \u2192 use "5m" as default.
+
+## Disambiguation: conflicting interval signals
+
+When the input contains multiple time references that could be intervals, apply these rules:
+1. The most specific/granular interval wins as the "interval" field.
+2. The broader time reference becomes "expiresIn" context (if it specifies a duration).
+
+Granularity order (most specific first): seconds \u2192 minutes \u2192 hours \u2192 days.
+
+Examples:
+- "every day run this command with intervals of 10 minutes per run" \u2192 interval: "10m", expiresIn: "1d"
+  ("intervals of 10 minutes" is more specific than "every day")
+- "check deploy every day for a week at 10 minute intervals" \u2192 interval: "10m", expiresIn: "7d"
+- "run tests daily with 5 minute checks" \u2192 interval: "5m", expiresIn: "1d"
+- "every hour check build every 2 minutes" \u2192 interval: "2m", expiresIn: "1h"
+
+## Execution count extraction (maxRuns)
+
+When the user specifies a finite number of executions, extract it as "maxRuns":
+- "only 10 times" \u2192 maxRuns: 10
+- "do this 5 times" \u2192 maxRuns: 5
+- "repeat 3 times" \u2192 maxRuns: 3
+- "just once" / "one time" \u2192 maxRuns: 1
+- "twice" / "two times" \u2192 maxRuns: 2
+- No count mentioned \u2192 omit maxRuns entirely
+
+Strip the count language from the prompt (e.g. "only 10 times", "5 times", "twice").
+
+## Custom expiry extraction (expiresIn)
+
+When the user specifies a duration/deadline for how long the job should stay active, extract it as "expiresIn":
+- "for the next week" / "for a week" \u2192 expiresIn: "7d"
+- "for 2 days" \u2192 expiresIn: "2d"
+- "for the next hour" \u2192 expiresIn: "1h"
+- "until tomorrow" \u2192 expiresIn: "1d"
+- "for 30 minutes" \u2192 expiresIn: "30m"
+- No duration mentioned \u2192 omit expiresIn entirely (default: 3 days)
+
+Strip the expiry language from the prompt.
+
+## Prompt cleaning rules
+
+1. Strip conversational filler: remove leading "can you", "could you", "please", "I want you to", "I need you to", "go ahead and", "make sure to", "try to".
+2. Strip scheduling language: remove "every X minutes", "hourly", "daily", "continuously", "keep", "repeatedly", "nonstop", "on repeat", "periodically", etc.
+3. Preserve slash commands and their arguments verbatim: "/deploy staging", "/babysit-prs", "/lint --fix".
+4. Preserve technical content exactly: file paths, command flags, branch names, URLs.
+5. Do NOT rephrase or summarize the task \u2014 keep the user's own words minus filler and scheduling.
+
+## Disambiguation: "every" as quantifier vs frequency
+
+"every" followed by a time expression (number + unit, or time noun) = frequency \u2192 extract it.
+"every" followed by a non-time noun = quantifier (part of the task) \u2192 keep it in the prompt.
+
+Frequency: "check deploy every 5 minutes", "run hourly", "every 2h run tests"
+Quantifier: "check every PR", "review every file", "test every endpoint", "lint every module"
+
+## Disambiguation: time words inside task names
+
+If a time word (hourly, daily, etc.) is part of a compound noun or script name, it describes the TASK, not the frequency.
+"run the hourly backup script" \u2192 interval "5m", prompt "run the hourly backup script"
+"check the daily report" \u2192 interval "5m", prompt "check the daily report"
+"execute the 5-minute health check" \u2192 interval "5m", prompt "execute the 5-minute health check"
+
+# Examples
+
+Input: "can you run tests every 5 minutes"
+Output: {"interval":"5m","prompt":"run tests"}
+
+Input: "please check the deploy hourly"
+Output: {"interval":"1h","prompt":"check the deploy"}
+
+Input: "navigate to my gh pr list and pick one item to work on every 2 minutes"
+Output: {"interval":"2m","prompt":"navigate to my gh pr list and pick one item to work on"}
+
+Input: "make a git commit with empty message to trigger ci cd hourly"
+Output: {"interval":"1h","prompt":"make a git commit with empty message to trigger ci cd"}
+
+Input: "check for new issues on github twice an hour"
+Output: {"interval":"30m","prompt":"check for new issues on github"}
+
+Input: "run the test suite"
+Output: {"interval":"5m","prompt":"run the test suite"}
+
+Input: "keep monitoring the logs"
+Output: {"interval":"1m","prompt":"monitor the logs"}
+
+Input: "check every PR for review comments"
+Output: {"interval":"5m","prompt":"check every PR for review comments"}
+
+Input: "I want you to continuously watch the build pipeline"
+Output: {"interval":"1m","prompt":"watch the build pipeline"}
+
+Input: "run the hourly backup script every 30m"
+Output: {"interval":"30m","prompt":"run the hourly backup script"}
+
+Input: "/deploy staging every 10m"
+Output: {"interval":"10m","prompt":"/deploy staging"}
+
+Input: "could you maybe check if the tests pass"
+Output: {"interval":"5m","prompt":"check if the tests pass"}
+
+Input: "check for git commits from origin every minute"
+Output: {"interval":"1m","prompt":"check for git commits from origin"}
+
+Input: "tell me a joke every 2 minutes only 10 times"
+Output: {"interval":"2m","prompt":"tell me a joke","maxRuns":10}
+
+Input: "check PRs every day for the next week"
+Output: {"interval":"1d","prompt":"check PRs","expiresIn":"7d"}
+
+Input: "run tests every 5m do this 3 times"
+Output: {"interval":"5m","prompt":"run tests","maxRuns":3}
+
+Input: "check build every hour only 5 times for 2 days"
+Output: {"interval":"1h","prompt":"check build","maxRuns":5,"expiresIn":"2d"}
+
+Input: "every day run echo hello world with intervals of 10 minutes per run"
+Output: {"interval":"10m","prompt":"run echo hello world","expiresIn":"1d"}
+
+Input: "every hour check build every 2 minutes"
+Output: {"interval":"2m","prompt":"check build","expiresIn":"1h"}`;
+async function llmParseInput(raw, llm) {
+  try {
+    const response = await llm.complete({
+      messages: [
+        { role: "system", content: REPEAT_SYSTEM_PROMPT },
+        { role: "user", content: raw }
+      ],
+      maxTokens: 200,
+      temperature: 0
+    });
+    const text = response.content.trim();
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) return parseInput(raw);
+    const parsed = JSON.parse(jsonMatch[0]);
+    const interval = typeof parsed.interval === "string" ? parsed.interval : DEFAULT_INTERVAL;
+    const prompt = typeof parsed.prompt === "string" ? parsed.prompt : "";
+    if (!/^\d+[smhd]$/.test(interval)) return parseInput(raw);
+    const maxRuns = typeof parsed.maxRuns === "number" && Number.isInteger(parsed.maxRuns) && parsed.maxRuns > 0 ? parsed.maxRuns : void 0;
+    const expiresIn = typeof parsed.expiresIn === "string" && /^\d+[smhd]$/.test(parsed.expiresIn) ? parsed.expiresIn : void 0;
+    return { interval, prompt, maxRuns, expiresIn };
+  } catch (e) {
+    return parseInput(raw);
+  }
+}
+async function repeat(ctx, args = []) {
+  if (!ctx.repeatManager) {
+    return _chalk2.default.yellow("Repeat manager not available.");
+  }
+  const raw = args.join(" ").trim();
+  if (_optionalChain([args, 'access', _ => _[0], 'optionalAccess', _2 => _2.toLowerCase, 'call', _3 => _3()]) === "help") {
+    return showUsage();
+  }
+  if (_optionalChain([args, 'access', _4 => _4[0], 'optionalAccess', _5 => _5.toLowerCase, 'call', _6 => _6()]) === "cancel") {
+    const id = _optionalChain([args, 'access', _7 => _7[1], 'optionalAccess', _8 => _8.trim, 'call', _9 => _9()]);
+    if (!id) {
+      return _chalk2.default.yellow("Usage: /repeat cancel <job-id>");
+    }
+    const ok = ctx.repeatManager.cancel(id);
+    return ok ? _chalk2.default.green(`Cancelled recurring job ${_chalk2.default.bold(id)}.`) : _chalk2.default.yellow(`No active job with ID ${_chalk2.default.bold(id)}.`);
+  }
+  if (_optionalChain([args, 'access', _10 => _10[0], 'optionalAccess', _11 => _11.toLowerCase, 'call', _12 => _12()]) === "list") {
+    const jobs = ctx.repeatManager.list();
+    if (jobs.length === 0) {
+      return _chalk2.default.gray("No recurring jobs scheduled.");
+    }
+    const lines2 = [_chalk2.default.bold("Active recurring jobs:"), ""];
+    for (const job2 of jobs) {
+      const remaining = Math.max(0, job2.expiresAt - Date.now());
+      const hoursLeft = Math.round(remaining / (60 * 60 * 1e3));
+      lines2.push(
+        `  ${_chalk2.default.cyan(job2.id)}  ${_chalk2.default.white(job2.humanInterval)}  ${_chalk2.default.gray(job2.cronExpression)}`,
+        `    ${_chalk2.default.gray("prompt:")} ${job2.prompt}`
+      );
+      if (job2.maxRuns !== void 0) {
+        lines2.push(`    ${_chalk2.default.gray(`runs: ${job2.runCount}/${job2.maxRuns}`)}`);
+      }
+      lines2.push(
+        `    ${_chalk2.default.gray(`expires in ~${hoursLeft}h`)}`,
+        ""
+      );
+    }
+    return lines2.join("\n");
+  }
+  if (!raw) {
+    return showUsage();
+  }
+  if (args.length === 1) {
+    const SUBCOMMANDS = ["list", "cancel", "help"];
+    const firstArg = args[0].toLowerCase();
+    if (!SUBCOMMANDS.includes(firstArg)) {
+      const closest = findClosestSubcommand(firstArg, SUBCOMMANDS);
+      if (closest) {
+        return _chalk2.default.yellow(`Unknown subcommand "${args[0]}". Did you mean ${_chalk2.default.bold(`/repeat ${closest}`)}?`) + "\n\n" + showUsage();
+      }
+    }
+  }
+  let interval;
+  let prompt;
+  let maxRuns;
+  let expiresIn;
+  if (ctx.llm) {
+    console.log(_chalk2.default.gray("Parsing schedule..."));
+    const llmResult = await llmParseInput(raw, ctx.llm);
+    interval = llmResult.interval;
+    prompt = llmResult.prompt;
+    maxRuns = llmResult.maxRuns;
+    expiresIn = llmResult.expiresIn;
+  } else {
+    const regexResult = parseInput(raw);
+    interval = regexResult.interval;
+    prompt = regexResult.prompt;
+  }
+  if (!prompt) {
+    return showUsage();
+  }
+  let cron;
+  try {
+    cron = intervalToCron(interval);
+  } catch (err) {
+    return _chalk2.default.red(`Invalid interval "${interval}": ${err.message}`);
+  }
+  const expiresInMs = expiresIn ? shorthandToMs(expiresIn) : void 0;
+  const expiresInHuman = expiresIn ? shorthandToHuman(expiresIn) : void 0;
+  const job = ctx.repeatManager.schedule(prompt, cron.intervalMs, cron.cronExpression, cron.humanReadable, {
+    maxRuns,
+    expiresInMs
+  });
+  const lines = [
+    _chalk2.default.green("Recurring job scheduled!"),
+    "",
+    `  ${_chalk2.default.gray("Job ID:")}      ${_chalk2.default.cyan(job.id)}`,
+    `  ${_chalk2.default.gray("Prompt:")}      ${prompt}`,
+    `  ${_chalk2.default.gray("Cadence:")}     ${cron.humanReadable}`,
+    `  ${_chalk2.default.gray("Cron:")}        ${cron.cronExpression}`
+  ];
+  if (maxRuns !== void 0) {
+    lines.push(`  ${_chalk2.default.gray("Limit:")}       ${maxRuns} runs`);
+  }
+  if (cron.roundedNote) {
+    lines.push(`  ${_chalk2.default.yellow("Note:")}        ${cron.roundedNote}`);
+  }
+  const expiryLabel = _nullishCoalesce(expiresInHuman, () => ( "3 days"));
+  lines.push(
+    "",
+    _chalk2.default.gray(`Recurring jobs auto-expire after ${expiryLabel}.`),
+    _chalk2.default.gray(`Cancel sooner with: /repeat cancel ${job.id}`),
+    ""
+  );
+  return lines.join("\n");
+}
+function levenshtein(a, b) {
+  const m = a.length, n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+    }
+  }
+  return dp[m][n];
+}
+function findClosestSubcommand(input, subcommands) {
+  let best = null;
+  let bestDist = 3;
+  for (const cmd of subcommands) {
+    const dist = levenshtein(input, cmd);
+    if (dist < bestDist) {
+      bestDist = dist;
+      best = cmd;
+    }
+  }
+  return best;
+}
+function showUsage() {
+  return `
+${_chalk2.default.cyan("/repeat \u2014 Schedule a recurring prompt")}
+
+${_chalk2.default.yellow("Usage:")}
+  /repeat [interval] <prompt>     Schedule a recurring prompt
+  /repeat list                    Show active jobs
+  /repeat cancel <id>             Cancel a job
+
+${_chalk2.default.yellow("Interval formats:")}
+  5m       every 5 minutes
+  2h       every 2 hours
+  1d       every day
+  30s      every 30 seconds (rounded to 1m)
+
+${_chalk2.default.yellow("Examples:")}
+  /repeat 5m run tests
+  /repeat check the deploy every 20m
+  /repeat run tests every 5 minutes
+  /repeat 2h check build status
+  /repeat list
+  /repeat cancel abc123
+`;
+}
+
+
+
+
+
+
+exports.metadata = metadata; exports.parseInput = parseInput; exports.intervalToCron = intervalToCron; exports.repeat = repeat;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * /repeat — schedule a recurring prompt at a fixed interval.
+ *
+ * Usage:
+ *   /repeat [interval] <prompt>
+ *   /repeat cancel <id>
+ *   /repeat list
+ */

package/dist/{chunk-O4IF4NJT.cjs → chunk-56SWIDEL.cjs}

@@ -7,7 +7,7 @@ var _chunkNNPAM4HCcjs = require('./chunk-NNPAM4HC.cjs');
 
 
 
-var _chunkBWN2CLLMcjs = require('./chunk-BWN2CLLM.cjs');
+var _chunkCB4E2T5Ncjs = require('./chunk-CB4E2T5N.cjs');
 
 
 var _chunkSEKD5FH3cjs = require('./chunk-SEKD5FH3.cjs');
@@ -176,13 +176,13 @@ async function loadConfigForScope(scopeInput, workspaceRoot) {
     throw new Error(`Invalid scope "${scopeInput}". Use: user or project.`);
   }
   if (scope === "user") {
-    return { config: await _chunkBWN2CLLMcjs.loadConfig.call(void 0, ), scope };
+    return { config: await _chunkCB4E2T5Ncjs.loadConfig.call(void 0, ), scope };
   }
   if (!workspaceRoot) {
     throw new Error("Workspace root is required for project scope.");
   }
   const projectConfigPath = _path2.default.join(workspaceRoot, _chunkSEKD5FH3cjs.PROJECT_DIR_NAME, "config.json");
-  return { config: await _chunkBWN2CLLMcjs.loadConfig.call(void 0, projectConfigPath), scope };
+  return { config: await _chunkCB4E2T5Ncjs.loadConfig.call(void 0, projectConfigPath), scope };
 }
 function syncRuntimeConfig(runtimeConfig, updatedConfig) {
   if (!runtimeConfig) return;
@@ -439,7 +439,7 @@ async function handleAdd(manager, config, args, workspaceRoot) {
       if (wasAutoConnectDisabled) reenabledParts.push("auto-connect");
       const reenabled = reenabledParts.join(" and ");
       try {
-        await _chunkBWN2CLLMcjs.saveConfig.call(void 0, targetConfig);
+        await _chunkCB4E2T5Ncjs.saveConfig.call(void 0, targetConfig);
         syncRuntimeConfig(config, targetConfig);
         try {
           await manager.connect(existing);
@@ -464,7 +464,7 @@ async function handleAdd(manager, config, args, workspaceRoot) {
     }
     existing.autoConnect = true;
     try {
-      await _chunkBWN2CLLMcjs.saveConfig.call(void 0, targetConfig);
+      await _chunkCB4E2T5Ncjs.saveConfig.call(void 0, targetConfig);
       syncRuntimeConfig(config, targetConfig);
       try {
         await manager.disconnect(name);
@@ -483,7 +483,7 @@ async function handleAdd(manager, config, args, workspaceRoot) {
   }
   targetConfig.mcp.servers.push(newServer);
   try {
-    await _chunkBWN2CLLMcjs.saveConfig.call(void 0, targetConfig);
+    await _chunkCB4E2T5Ncjs.saveConfig.call(void 0, targetConfig);
     syncRuntimeConfig(config, targetConfig);
     try {
       await manager.connect(newServer);
@@ -540,7 +540,7 @@ async function handleRemove(manager, config, args, workspaceRoot) {
   }
   targetConfig.mcp.servers.splice(serverIndex, 1);
   try {
-    await _chunkBWN2CLLMcjs.saveConfig.call(void 0, targetConfig);
+    await _chunkCB4E2T5Ncjs.saveConfig.call(void 0, targetConfig);
     syncRuntimeConfig(config, targetConfig);
     return `Removed "${serverName}" from ${scopeLabel ? `${scopeLabel} config` : "config"}`;
   } catch (error) {

package/dist/{chunk-CAMZTXV6.js → chunk-5K6NGAVM.js}

@@ -1,7 +1,7 @@
 import {
   loadConfig,
   saveConfig
-} from "./chunk-P47WPOXN.js";
+} from "./chunk-ZYVS43MU.js";
 import {
   t
 } from "./chunk-APIXPPMT.js";