opencode-jobs 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Connor Fraser-Grant
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,204 @@
+# opencode-jobs
+
+> **Status:** v0.x — Linux-only early release. The job format, tool names,
+> and CLI may still change.
+
+Recurring scheduled jobs for [opencode](https://opencode.ai), backed by
+systemd user timers. Job definitions are git-committable files in your repo,
+each job runs through a frozen POSIX shell script, and every run appends
+JSONL history your agent can read back. Jobs are just agent prompts — with
+optional session continuity so a nightly job can build on what it learned
+yesterday.
+
+## Install
+
+Install the package globally, then wire the plugin and bundled skill into the
+current project:
+
+```sh
+npm install --global opencode-jobs
+opencode-jobs install
+```
+
+Pass a project path when running the command from elsewhere:
+
+```sh
+opencode-jobs install /path/to/project
+```
+
+The installer is idempotent. It adds `opencode-jobs` to the project's local
+`plugin` array and copies the bundled skill to
+`.opencode/skills/opencode-jobs/SKILL.md` — the skill teaches your agent the
+job file format, session modes, and the day-to-day workflow. It does not
+enable timers; create a job first, then use `enable_project`. If an existing
+config contains comments or malformed JSON, the installer leaves it untouched
+and reports the manual change required.
+
+Job files are committed agent prompts that run on your machine on a
+schedule — only install and enable projects whose
+`.opencode/scheduler/jobs/` you trust, the same care you would take before
+running an unfamiliar repository's build.
+
+Alternatively, add the package manually to the project root `opencode.json`
+or global `~/.config/opencode/opencode.json`:
+
+```json
+{
+  "plugin": ["opencode-jobs"]
+}
+```
+
+Restart opencode and ask your agent to schedule something, e.g.
+_"schedule a job that reviews new commits every weekday at 9am"_.
+
+## Uninstall
+
+Reverse an install from anywhere:
+
+```sh
+opencode-jobs uninstall            # current directory
+opencode-jobs uninstall /path/to/project
+```
+
+Uninstall stops and removes the project's systemd units (if enabled),
+removes the plugin entry from the project config, and deletes the copied
+skill — a skill you have modified locally is kept and reported, and a config
+the uninstaller cannot rewrite safely is left untouched with a non-zero
+exit. Job definitions, run history, session state, and logs are kept.
+
+Add `--purge` to also delete the project's job definitions
+(`.opencode/scheduler/`) and its scheduler data (run scripts, run history,
+session state, and logs):
+
+```sh
+opencode-jobs uninstall --purge
+```
+
+## CLI
+
+```text
+opencode-jobs install [projectDir]
+opencode-jobs uninstall [projectDir] [--purge]
+```
+
+The CLI is installed as the `opencode-jobs` npm executable. `projectDir`
+defaults to the current directory. Both commands print a JSON result so they
+can also be used from setup scripts and CI.
+
+## Tools
+
+| Tool              | What it does                                                                                   |
+| ----------------- | ---------------------------------------------------------------------------------------------- |
+| `schedule_job`    | Create or update a job (cron schedule, prompt or custom command, session mode, guard, timeout) |
+| `list_jobs`       | List job definitions in the project with next/last run status                                  |
+| `get_job`         | Show one job: definition, timer state, last runs, recent log tail                              |
+| `run_job`         | Fire a job now, through the exact script the timer would run                                   |
+| `job_logs`        | Tail a job's log (scheduled and manual runs both append)                                       |
+| `delete_job`      | Delete a job, its units, run script, and session state                                         |
+| `enable_project`  | Install systemd user units for all jobs in the project and register it                         |
+| `disable_project` | Stop and remove the project's units (jobs and history are kept)                                |
+| `list_projects`   | List all projects that have enabled jobs                                                       |
+
+## Job definitions
+
+Jobs live in your repo at `.opencode/scheduler/jobs/<slug>.json` — review
+them in PRs like any other code:
+
+```json
+{
+  "slug": "nightly-review",
+  "name": "Nightly Review",
+  "schedule": "0 9 * * 1-5",
+  "run": {
+    "prompt": "Review commits since the last run and flag risky changes."
+  },
+  "session": "compact+last",
+  "guard": "! git diff --quiet",
+  "timeoutSeconds": 1800
+}
+```
+
+- `schedule` — 5-field cron expression (`m h dom mon dow`, names and ranges
+  supported), mapped to `OnCalendar` systemd timers.
+- `run` — either a natural-language `prompt` (run with `opencode run`), or a
+  `command` + optional `arguments` for a project custom command. Optional
+  `agent` and `model` (`"provider/model"`) select who runs it.
+- `session` — continuity between runs (below).
+- `guard` — shell command run first; a non-zero exit skips the run (recorded
+  as `skipped`). Example: `"! git diff --quiet"` runs only when the repo has
+  changes.
+- `timeoutSeconds` — hard limit; systemd stops the run with SIGTERM.
+
+### Session modes
+
+| Mode           | Behavior                                                                                                                 |
+| -------------- | ------------------------------------------------------------------------------------------------------------------------ |
+| `new`          | Fresh session each run (default)                                                                                         |
+| `persist`      | Continue the same session every run (`opencode run --session`)                                                           |
+| `compact`      | Continue the same session; after each run the history is compacted into a summary the next run starts from               |
+| `compact+last` | Like `compact`, but the run's final result is re-injected after the summary so the next run starts from summary + result |
+
+Tracked modes (`persist`/`compact`/`compact+last`) self-heal a deleted or
+stale session by retrying once with a fresh session.
+
+## How it works
+
+- `enable_project` generates, for each job: a frozen POSIX `run-<slug>.sh`
+  script, a `opencode-sched-<scope>-<slug>.service` + `.timer` unit pair,
+  and enables the timer. `disable_project` removes them.
+- Run scripts work standalone: they append a JSONL record (status, exit
+  code, duration, session id) per run, capture `--format json` output for
+  tracked session modes, and never leave temp files behind.
+- A global registry tracks enabled projects so `list_projects` and
+  `disable_project` work from any session.
+- Schedules are cron expressions compiled to systemd `OnCalendar` and
+  verified with `systemd-analyze verify` before install.
+
+## Storage
+
+| What                | Where                                                                  |
+| ------------------- | ---------------------------------------------------------------------- |
+| Job definitions     | `<project>/.opencode/scheduler/jobs/<slug>.json` (git-committed)       |
+| Run scripts         | `~/.config/opencode/scheduler/scopes/<scopeId>/run-<slug>.sh`          |
+| Run history (JSONL) | `~/.config/opencode/scheduler/runs/<scopeId>/<slug>.jsonl`             |
+| Session state       | `~/.config/opencode/scheduler/sessions/<scopeId>/<slug>.txt`           |
+| Job logs            | `~/.config/opencode/logs/scheduler/<scopeId>/<slug>.log`               |
+| Project registry    | `~/.config/opencode/scheduler/registry.json`                           |
+| systemd units       | `~/.config/systemd/user/opencode-sched-<scope>-<slug>.{service,timer}` |
+
+`scopeId` is a stable hash of the project path, so multiple projects can
+define jobs without colliding. Because it is path-derived, moving or renaming
+a project directory orphans its units, history, and registry entry — run
+`opencode-jobs uninstall --purge` from the old path before moving, or clean
+up `~/.config/opencode/scheduler/` (and the unit files) manually afterwards.
+
+## Configuration
+
+- `OPENCODE_SCHEDULER_OPENCODE_PATH` — absolute path to the `opencode`
+  binary the run scripts invoke (default: resolved from `PATH`, then
+  `~/.opencode/bin/opencode`, then common install locations).
+
+## Requirements
+
+- Linux with a systemd user session (jobs run via `systemctl --user`)
+- `curl` (used by `compact`/`compact+last` modes only)
+- POSIX `sh` (generated scripts are `sh`/`dash`-verified)
+- The `opencode` CLI available to the timer environment
+
+Not supported on macOS or Windows.
+
+## Development
+
+```
+npm install
+npm run check    # prettier + eslint + tsc
+npm run build    # Bun plugin bundle + Node CLI bundle + declarations
+npm run smoke    # build, scheduler behavior, CLI install, and package contents
+```
+
+Node >= 20 is required for the CLI and dev toolchain; the plugin runs on Bun
+inside opencode.
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,405 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import path6 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/install.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, rmSync as rmSync2, rmdirSync, statSync } from "node:fs";
+import path5 from "node:path";
+
+// src/json.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function stringProperty(record, key) {
+  const value = record[key];
+  return typeof value === "string" ? value : undefined;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/paths.ts
+import { chmodSync, mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { homedir } from "node:os";
+function configRoot() {
+  return process.env.XDG_CONFIG_HOME ?? path.join(homedir(), ".config");
+}
+function schedulerDirectory() {
+  return path.join(configRoot(), "opencode", "scheduler");
+}
+function registryPath() {
+  return path.join(schedulerDirectory(), "registry.json");
+}
+function scopeDirectory(scopeId) {
+  return path.join(schedulerDirectory(), "scopes", scopeId);
+}
+function runsDirectory(scopeId) {
+  return path.join(schedulerDirectory(), "runs", scopeId);
+}
+function sessionStateDirectory(scopeId) {
+  return path.join(schedulerDirectory(), "sessions", scopeId);
+}
+function logDirectory(scopeId) {
+  return path.join(configRoot(), "opencode", "logs", "scheduler", scopeId);
+}
+function systemdUserDirectory() {
+  return path.join(configRoot(), "systemd", "user");
+}
+function unitBase(scopeId, slug) {
+  return `opencode-sched-${scopeId}-${slug}`;
+}
+function timerUnit(base) {
+  return `${base}.timer`;
+}
+function serviceUnit(base) {
+  return `${base}.service`;
+}
+function runScriptPath(scopeId, slug) {
+  return path.join(scopeDirectory(scopeId), `run-${slug}.sh`);
+}
+function slugify(input) {
+  const slug = input.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-+|-+$/g, "").slice(0, 64);
+  return slug.length > 0 ? slug : "job";
+}
+function atomicWrite(file, content) {
+  mkdirSync(path.dirname(file), { recursive: true });
+  const temporary = `${file}.tmp`;
+  writeFileSync(temporary, content);
+  renameSync(temporary, file);
+}
+function deriveScopeId(workdir) {
+  const abs = path.resolve(workdir);
+  const hash = createHash("sha256").update(abs).digest("hex").slice(0, 12);
+  return `${slugify(path.basename(abs))}-${hash}`;
+}
+
+// src/project.ts
+import path4 from "node:path";
+
+// src/registry.ts
+import { readFileSync } from "node:fs";
+import path2 from "node:path";
+function isRegistryEntry(value) {
+  if (!isRecord(value))
+    return false;
+  return stringProperty(value, "scopeId") !== undefined && stringProperty(value, "workdir") !== undefined && stringProperty(value, "enabledAt") !== undefined && stringProperty(value, "updatedAt") !== undefined && Array.isArray(value.jobs) && value.jobs.every((job) => typeof job === "string");
+}
+function loadRegistry() {
+  try {
+    const parsed = JSON.parse(readFileSync(registryPath(), "utf8"));
+    if (!isRecord(parsed) || parsed.version !== 1 || !isRecord(parsed.projects)) {
+      return { version: 1, projects: {} };
+    }
+    const projects = {};
+    for (const [key, value] of Object.entries(parsed.projects)) {
+      if (isRegistryEntry(value))
+        projects[key] = value;
+    }
+    return { version: 1, projects };
+  } catch {
+    return { version: 1, projects: {} };
+  }
+}
+function saveRegistry(registry) {
+  atomicWrite(registryPath(), `${JSON.stringify(registry, undefined, 2)}
+`);
+}
+function registryEntry(workdir) {
+  return loadRegistry().projects[path2.resolve(workdir)];
+}
+
+// src/systemd.ts
+import { existsSync, mkdirSync as mkdirSync2, readdirSync, rmSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import path3 from "node:path";
+var SESSION_ID_SED = String.raw`s/.*"sessionID":"\([^"]*\)".*/\1/p`;
+var DEFAULT_PROVIDER_SED = String.raw`s/.*"default"[[:space:]]*:[[:space:]]*{[^}]*"\([^"]*\)"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p`;
+var DEFAULT_MODEL_SED = String.raw`s/.*"default"[[:space:]]*:[[:space:]]*{[^}]*"\([^"]*\)"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\2/p`;
+function systemctl(systemctlArguments) {
+  const result = spawnSync("systemctl", ["--user", ...systemctlArguments], {
+    encoding: "utf8"
+  });
+  return {
+    ok: result.status === 0,
+    stdout: result.stdout.trim(),
+    stderr: result.stderr.trim()
+  };
+}
+function removeJobUnits(scopeId, slug) {
+  const base = unitBase(scopeId, slug);
+  systemctl(["disable", "--now", timerUnit(base)]);
+  for (const file of [
+    path3.join(systemdUserDirectory(), timerUnit(base)),
+    path3.join(systemdUserDirectory(), serviceUnit(base))
+  ]) {
+    if (existsSync(file))
+      rmSync(file);
+  }
+  const script = runScriptPath(scopeId, slug);
+  if (existsSync(script))
+    rmSync(script);
+}
+
+// src/project.ts
+function disableProject(workdir) {
+  const abs = path4.resolve(workdir);
+  const entry = registryEntry(abs);
+  if (entry === undefined)
+    return `Project is not enabled: ${abs}`;
+  for (const slug of entry.jobs)
+    removeJobUnits(entry.scopeId, slug);
+  systemctl(["daemon-reload"]);
+  const registry = loadRegistry();
+  const { [abs]: _omitted, ...remainingProjects } = registry.projects;
+  registry.projects = remainingProjects;
+  saveRegistry(registry);
+  return [
+    `Disabled ${String(entry.jobs.length)} job(s) for ${abs}`,
+    `Run history kept at ${runsDirectory(entry.scopeId)}`,
+    `Logs kept at ${logDirectory(entry.scopeId)}`
+  ].join(`
+`);
+}
+
+// src/install.ts
+var PACKAGE_NAME = "opencode-jobs";
+var SKILL_NAME = "opencode-jobs";
+var CONFIG_SCHEMA = "https://opencode.ai/config.json";
+var CONFIG_LOCATIONS = [
+  "opencode.json",
+  "opencode.jsonc",
+  path5.join(".opencode", "opencode.json"),
+  path5.join(".opencode", "opencode.jsonc")
+];
+function existingConfigPath(projectDirectory) {
+  for (const relativePath of CONFIG_LOCATIONS) {
+    const configPath = path5.join(projectDirectory, relativePath);
+    if (existsSync2(configPath))
+      return configPath;
+  }
+  return;
+}
+function readConfig(configPath) {
+  try {
+    const value = JSON.parse(readFileSync2(configPath, "utf8"));
+    return isRecord(value) && !Array.isArray(value) ? value : undefined;
+  } catch {
+    return;
+  }
+}
+function isPackageSpecifier(value) {
+  return value === PACKAGE_NAME || typeof value === "string" && value.startsWith(`${PACKAGE_NAME}@`);
+}
+function isPackageReference(entry) {
+  if (typeof entry === "string")
+    return isPackageSpecifier(entry);
+  return Array.isArray(entry) && isPackageSpecifier(entry[0]);
+}
+function installPluginConfig(projectDirectory) {
+  const existingPath = existingConfigPath(projectDirectory);
+  const configPath = existingPath ?? path5.join(projectDirectory, "opencode.json");
+  if (existingPath === undefined) {
+    atomicWrite(configPath, `${JSON.stringify({
+      $schema: CONFIG_SCHEMA,
+      plugin: [PACKAGE_NAME]
+    }, undefined, 2)}
+`);
+    return { status: "added", configPath };
+  }
+  const config = readConfig(configPath);
+  if (config === undefined)
+    return { status: "manual", configPath };
+  const plugins = config.plugin;
+  if (plugins !== undefined && !Array.isArray(plugins)) {
+    return { status: "manual", configPath };
+  }
+  const entries = Array.isArray(plugins) ? plugins : [];
+  if (entries.some((entry) => isPackageReference(entry))) {
+    return { status: "present", configPath };
+  }
+  config.plugin = [...entries, PACKAGE_NAME];
+  atomicWrite(configPath, `${JSON.stringify(config, undefined, 2)}
+`);
+  return { status: "added", configPath };
+}
+function installSkill(projectDirectory, packageDirectory) {
+  const sourcePath = path5.join(packageDirectory, "skill", SKILL_NAME, "SKILL.md");
+  const skillPath = path5.join(projectDirectory, ".opencode", "skills", SKILL_NAME, "SKILL.md");
+  const content = readFileSync2(sourcePath, "utf8");
+  if (existsSync2(skillPath) && readFileSync2(skillPath, "utf8") === content) {
+    return { status: "unchanged", skillPath };
+  }
+  atomicWrite(skillPath, content);
+  return { status: "written", skillPath };
+}
+function installProject(projectDirectory, packageDirectory) {
+  const resolvedProject = path5.resolve(projectDirectory);
+  if (!existsSync2(resolvedProject) || !statSync(resolvedProject).isDirectory()) {
+    throw new Error(`Project directory does not exist: ${resolvedProject}`);
+  }
+  return {
+    projectDirectory: resolvedProject,
+    plugin: installPluginConfig(resolvedProject),
+    skill: installSkill(resolvedProject, packageDirectory)
+  };
+}
+function removeDirectoryIfEmpty(directory) {
+  try {
+    rmdirSync(directory);
+  } catch {}
+}
+function uninstallPluginConfig(projectDirectory) {
+  const existingPath = existingConfigPath(projectDirectory);
+  const configPath = existingPath ?? path5.join(projectDirectory, "opencode.json");
+  if (existingPath === undefined)
+    return { status: "absent", configPath };
+  const config = readConfig(configPath);
+  if (config === undefined)
+    return { status: "manual", configPath };
+  const plugins = config.plugin;
+  if (plugins !== undefined && !Array.isArray(plugins)) {
+    return { status: "manual", configPath };
+  }
+  const entries = Array.isArray(plugins) ? plugins : [];
+  const remaining = entries.filter((entry) => !isPackageReference(entry));
+  if (remaining.length === entries.length) {
+    return { status: "absent", configPath };
+  }
+  delete config.plugin;
+  const wasInstallerCreated = entries.length === 1 && Object.keys(config).length === 1 && config.$schema === CONFIG_SCHEMA;
+  if (wasInstallerCreated) {
+    rmSync2(configPath);
+  } else {
+    if (remaining.length > 0)
+      config.plugin = remaining;
+    atomicWrite(configPath, `${JSON.stringify(config, undefined, 2)}
+`);
+  }
+  return { status: "removed", configPath };
+}
+function uninstallSkill(projectDirectory, packageDirectory) {
+  const sourcePath = path5.join(packageDirectory, "skill", SKILL_NAME, "SKILL.md");
+  const skillDirectory = path5.join(projectDirectory, ".opencode", "skills", SKILL_NAME);
+  const skillPath = path5.join(skillDirectory, "SKILL.md");
+  if (!existsSync2(skillPath))
+    return { status: "absent", skillPath };
+  if (readFileSync2(skillPath, "utf8") !== readFileSync2(sourcePath, "utf8")) {
+    return { status: "kept-modified", skillPath };
+  }
+  rmSync2(skillDirectory, { recursive: true, force: true });
+  removeDirectoryIfEmpty(path5.dirname(skillDirectory));
+  removeDirectoryIfEmpty(path5.join(projectDirectory, ".opencode"));
+  return { status: "removed", skillPath };
+}
+function purgeProjectData(projectDirectory) {
+  const abs = path5.resolve(projectDirectory);
+  const scopeId = deriveScopeId(abs);
+  const targets = [
+    scopeDirectory(scopeId),
+    runsDirectory(scopeId),
+    sessionStateDirectory(scopeId),
+    logDirectory(scopeId),
+    path5.join(abs, ".opencode", "scheduler")
+  ];
+  const paths = [];
+  for (const target of targets) {
+    if (!existsSync2(target))
+      continue;
+    rmSync2(target, { recursive: true, force: true });
+    paths.push(target);
+  }
+  removeDirectoryIfEmpty(path5.join(abs, ".opencode"));
+  return { paths };
+}
+function uninstallProject(projectDirectory, packageDirectory, shouldPurge) {
+  const resolvedProject = path5.resolve(projectDirectory);
+  if (!existsSync2(resolvedProject) || !statSync(resolvedProject).isDirectory()) {
+    throw new Error(`Project directory does not exist: ${resolvedProject}`);
+  }
+  const wasEnabled = registryEntry(resolvedProject) !== undefined;
+  if (wasEnabled)
+    disableProject(resolvedProject);
+  const uninstall = {
+    projectDirectory: resolvedProject,
+    disabled: wasEnabled,
+    plugin: uninstallPluginConfig(resolvedProject),
+    skill: uninstallSkill(resolvedProject, packageDirectory)
+  };
+  if (shouldPurge)
+    uninstall.purge = purgeProjectData(resolvedProject);
+  return uninstall;
+}
+
+// src/cli.ts
+var USAGE = `Usage: opencode-jobs <command> [projectDir]
+
+Commands:
+  install [projectDir]            Add the plugin and bundled skill to a project (default: current directory)
+  uninstall [projectDir] [--purge]  Remove the plugin entry, skill, and systemd units from a project;
+                                  --purge also deletes job definitions and scheduler data
+  help                            Show this help`;
+function packageDirectory() {
+  return path6.resolve(path6.dirname(fileURLToPath(import.meta.url)), "..");
+}
+function printError(message) {
+  console.error(`Error: ${message}
+
+${USAGE}`);
+  process.exitCode = 1;
+}
+function parseUninstallArguments(arguments_) {
+  let project;
+  let shouldPurge = false;
+  for (const argument of arguments_) {
+    if (argument === "--purge") {
+      shouldPurge = true;
+    } else if (argument.startsWith("--")) {
+      throw new Error(`unknown option: ${argument}`);
+    } else if (project === undefined) {
+      project = argument;
+    } else {
+      throw new Error("uninstall accepts at most one project directory");
+    }
+  }
+  return { project, purge: shouldPurge };
+}
+var [command, ...rest] = process.argv.slice(2);
+if ([undefined, "help", "--help"].includes(command)) {
+  console.log(USAGE);
+} else if (command === "install") {
+  if (rest.length > 1) {
+    printError("install accepts at most one project directory");
+  } else {
+    try {
+      const result = installProject(rest[0] ?? process.cwd(), packageDirectory());
+      console.log(JSON.stringify(result, undefined, 2));
+      if (result.plugin.status === "manual") {
+        console.error(`Add "opencode-jobs" to the "plugin" array in ${result.plugin.configPath}; the installer did not rewrite that file.`);
+        process.exitCode = 1;
+      }
+    } catch (error) {
+      printError(errorMessage(error));
+    }
+  }
+} else if (command === "uninstall") {
+  try {
+    const { project, purge: shouldPurge } = parseUninstallArguments(rest);
+    const result = uninstallProject(project ?? process.cwd(), packageDirectory(), shouldPurge);
+    console.log(JSON.stringify(result, undefined, 2));
+    if (result.plugin.status === "manual") {
+      console.error(`Remove "opencode-jobs" from the "plugin" array in ${result.plugin.configPath}; the uninstaller did not rewrite that file.`);
+      process.exitCode = 1;
+    }
+    if (result.skill.status === "kept-modified") {
+      console.error(`Skill kept at ${result.skill.skillPath} (modified locally); delete it manually if unwanted.`);
+    }
+  } catch (error) {
+    printError(errorMessage(error));
+  }
+} else {
+  printError(`unknown command: ${command ?? "(missing)"}`);
+}

package/dist/cron.d.ts

@@ -0,0 +1,10 @@
+export interface CronSets {
+    minute: number[];
+    hour: number[];
+    dom: number[];
+    month: number[];
+    dow: number[];
+}
+export declare function parseCron(expression: string): CronSets;
+export declare function cronToOnCalendar(sets: CronSets): string[];
+export declare function describeCron(sets: CronSets): string;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { Hooks } from "@opencode-ai/plugin";
+declare const _default: () => Promise<Hooks>;
+export default _default;