augure 0.8.0 → 0.9.0

package/dist/chunk-XOMIXLMX.js

@@ -0,0 +1,1294 @@
+#!/usr/bin/env node
+import {
+  noopLogger
+} from "./chunk-62OPINAX.js";
+
+// ../skills/dist/manager.js
+import { readFile, writeFile, mkdir, readdir, rm, access } from "fs/promises";
+import { join } from "path";
+
+// ../skills/dist/parser.js
+import matter from "gray-matter";
+function parseSkillMd(content) {
+  const { data, content: body } = matter(content);
+  const meta = validateSkillMeta(data);
+  return { meta, body: body.trim() };
+}
+function serializeSkillMd(meta, body) {
+  return matter.stringify(body, JSON.parse(JSON.stringify(meta)));
+}
+function validateSkillMeta(raw) {
+  if (!raw.id || typeof raw.id !== "string")
+    throw new Error("skill.md: missing or invalid 'id'");
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(raw.id))
+    throw new Error(`skill.md: invalid id format '${raw.id}' (must be lowercase slug)`);
+  if (!raw.name || typeof raw.name !== "string")
+    throw new Error("skill.md: missing or invalid 'name'");
+  const version = typeof raw.version === "number" ? raw.version : 1;
+  if (!Number.isInteger(version) || version < 1)
+    throw new Error("skill.md: 'version' must be a positive integer");
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const created = typeof raw.created === "string" ? raw.created : now;
+  const updated = typeof raw.updated === "string" ? raw.updated : now;
+  const status = typeof raw.status === "string" ? raw.status : "draft";
+  const validStatuses = ["draft", "testing", "active", "paused", "broken"];
+  if (!validStatuses.includes(status))
+    throw new Error(`skill.md: invalid status '${status}'`);
+  const trigger = raw.trigger;
+  if (!trigger || typeof trigger !== "object")
+    throw new Error("skill.md: missing 'trigger'");
+  const triggerType = trigger.type;
+  if (!["cron", "manual", "event"].includes(triggerType))
+    throw new Error(`skill.md: invalid trigger.type '${triggerType}'`);
+  if (triggerType === "cron" && (!trigger.schedule || typeof trigger.schedule !== "string")) {
+    throw new Error("skill.md: cron trigger requires 'schedule'");
+  }
+  const sandbox = typeof raw.sandbox === "boolean" ? raw.sandbox : true;
+  const tools = Array.isArray(raw.tools) ? raw.tools : [];
+  const tags = Array.isArray(raw.tags) ? raw.tags : [];
+  return {
+    id: raw.id,
+    name: raw.name,
+    version,
+    created,
+    updated,
+    status,
+    trigger: {
+      type: triggerType,
+      schedule: trigger.schedule,
+      channel: trigger.channel
+    },
+    sandbox,
+    tools,
+    tags
+  };
+}
+
+// ../skills/dist/manager.js
+var SkillManager = class {
+  basePath;
+  constructor(basePath) {
+    this.basePath = basePath;
+  }
+  /** List all skills from the index (rebuilds if missing) */
+  async list() {
+    try {
+      const index = await this.readIndex();
+      return index.skills;
+    } catch {
+      const index = await this.rebuildIndex();
+      return index.skills;
+    }
+  }
+  /** Load a single skill by ID */
+  async get(id) {
+    const dir = join(this.basePath, id);
+    const mdContent = await readFile(join(dir, "skill.md"), "utf-8");
+    const { meta, body } = parseSkillMd(mdContent);
+    let code;
+    try {
+      code = await readFile(join(dir, "skill.ts"), "utf-8");
+    } catch {
+    }
+    let testCode;
+    try {
+      testCode = await readFile(join(dir, "skill.test.ts"), "utf-8");
+    } catch {
+    }
+    return { meta, body, code, testCode };
+  }
+  /** Save a skill to disk (creates directory, writes files, updates index) */
+  async save(skill) {
+    const dir = join(this.basePath, skill.meta.id);
+    await mkdir(dir, { recursive: true });
+    const mdContent = serializeSkillMd(skill.meta, skill.body);
+    await writeFile(join(dir, "skill.md"), mdContent, "utf-8");
+    if (skill.code !== void 0) {
+      await writeFile(join(dir, "skill.ts"), skill.code, "utf-8");
+    }
+    if (skill.testCode !== void 0) {
+      await writeFile(join(dir, "skill.test.ts"), skill.testCode, "utf-8");
+    }
+    await this.updateIndex(skill.meta);
+  }
+  /** Delete a skill directory and remove from index */
+  async delete(id) {
+    const dir = join(this.basePath, id);
+    await rm(dir, { recursive: true, force: true });
+    await this.removeFromIndex(id);
+  }
+  /** Update just the status of a skill */
+  async updateStatus(id, status) {
+    const skill = await this.get(id);
+    skill.meta.status = status;
+    skill.meta.updated = (/* @__PURE__ */ new Date()).toISOString();
+    await this.save(skill);
+  }
+  /** Bump version number, returns the new version */
+  async bumpVersion(id) {
+    const skill = await this.get(id);
+    skill.meta.version += 1;
+    skill.meta.updated = (/* @__PURE__ */ new Date()).toISOString();
+    await this.save(skill);
+    return skill.meta.version;
+  }
+  /** Save a run result to runs/<timestamp>.json */
+  async saveRun(result) {
+    const runsDir = join(this.basePath, result.skillId, "runs");
+    await mkdir(runsDir, { recursive: true });
+    const filename = `${result.timestamp.replace(/[:.]/g, "-")}.json`;
+    await writeFile(join(runsDir, filename), JSON.stringify(result, null, 2), "utf-8");
+  }
+  /** Load recent run results for a skill, sorted newest first */
+  async getRuns(id, limit = 10) {
+    const runsDir = join(this.basePath, id, "runs");
+    let files;
+    try {
+      files = await readdir(runsDir);
+    } catch {
+      return [];
+    }
+    const jsonFiles = files.filter((f) => f.endsWith(".json")).sort().reverse();
+    const results = [];
+    for (const file of jsonFiles.slice(0, limit)) {
+      try {
+        const raw = await readFile(join(runsDir, file), "utf-8");
+        results.push(JSON.parse(raw));
+      } catch {
+      }
+    }
+    return results;
+  }
+  /** Get the most recent run result */
+  async getLastRun(id) {
+    const runs = await this.getRuns(id, 1);
+    return runs[0] ?? null;
+  }
+  /** Rebuild skills-index.json by scanning all skill directories */
+  async rebuildIndex() {
+    await mkdir(this.basePath, { recursive: true });
+    let entries;
+    try {
+      entries = await readdir(this.basePath, { withFileTypes: true }).then((e) => e.filter((d) => d.isDirectory()).map((d) => d.name));
+    } catch {
+      entries = [];
+    }
+    const skills = [];
+    for (const dir of entries) {
+      try {
+        const mdContent = await readFile(join(this.basePath, dir, "skill.md"), "utf-8");
+        const { meta } = parseSkillMd(mdContent);
+        skills.push(metaToIndexEntry(meta));
+      } catch {
+      }
+    }
+    const index = { version: 1, skills };
+    await this.writeIndex(index);
+    return index;
+  }
+  /** Check if a skill exists on disk */
+  async exists(id) {
+    try {
+      await access(join(this.basePath, id, "skill.md"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async readIndex() {
+    const raw = await readFile(join(this.basePath, "skills-index.json"), "utf-8");
+    return JSON.parse(raw);
+  }
+  async writeIndex(index) {
+    await mkdir(this.basePath, { recursive: true });
+    await writeFile(join(this.basePath, "skills-index.json"), JSON.stringify(index, null, 2), "utf-8");
+  }
+  async updateIndex(meta) {
+    let index;
+    try {
+      index = await this.readIndex();
+    } catch {
+      index = { version: 1, skills: [] };
+    }
+    const entry = metaToIndexEntry(meta);
+    const idx = index.skills.findIndex((s) => s.id === meta.id);
+    if (idx >= 0) {
+      index.skills[idx] = entry;
+    } else {
+      index.skills.push(entry);
+    }
+    await this.writeIndex(index);
+  }
+  async removeFromIndex(id) {
+    let index;
+    try {
+      index = await this.readIndex();
+    } catch {
+      return;
+    }
+    index.skills = index.skills.filter((s) => s.id !== id);
+    await this.writeIndex(index);
+  }
+};
+function metaToIndexEntry(meta) {
+  return {
+    id: meta.id,
+    name: meta.name,
+    version: meta.version,
+    status: meta.status,
+    trigger: meta.trigger,
+    tags: meta.tags,
+    updated: meta.updated
+  };
+}
+
+// ../skills/dist/llm-parser.js
+function parseSkillResponse(content) {
+  const namedResult = parseNamedFences(content);
+  if (namedResult)
+    return namedResult;
+  const sectionResult = parseSectionHeaders(content);
+  if (sectionResult)
+    return sectionResult;
+  const sequentialResult = parseSequentialBlocks(content);
+  if (sequentialResult)
+    return sequentialResult;
+  return null;
+}
+function parseNamedFences(content) {
+  const fencePattern = /```\w*\s+(?:filename=)?(\S+)\s*\n([\s\S]*?)```/g;
+  const blocks = /* @__PURE__ */ new Map();
+  let match;
+  while ((match = fencePattern.exec(content)) !== null) {
+    blocks.set(match[1], match[2].trim());
+  }
+  const skillMd = blocks.get("skill.md");
+  const skillTs = blocks.get("skill.ts");
+  const skillTestTs = blocks.get("skill.test.ts");
+  if (skillMd && skillTs && skillTestTs) {
+    return { skillMd, skillTs, skillTestTs };
+  }
+  return null;
+}
+function parseSectionHeaders(content) {
+  const sections = /* @__PURE__ */ new Map();
+  const sectionPattern = /#{2,3}\s+(skill\.(?:md|ts|test\.ts))\s*\n+```\w*\n([\s\S]*?)```/g;
+  let match;
+  while ((match = sectionPattern.exec(content)) !== null) {
+    sections.set(match[1], match[2].trim());
+  }
+  const skillMd = sections.get("skill.md");
+  const skillTs = sections.get("skill.ts");
+  const skillTestTs = sections.get("skill.test.ts");
+  if (skillMd && skillTs && skillTestTs) {
+    return { skillMd, skillTs, skillTestTs };
+  }
+  return null;
+}
+function parseSequentialBlocks(content) {
+  const blockPattern = /```\w*\n([\s\S]*?)```/g;
+  const blocks = [];
+  let match;
+  while ((match = blockPattern.exec(content)) !== null) {
+    blocks.push(match[1].trim());
+  }
+  if (blocks.length >= 3) {
+    return {
+      skillMd: blocks[0],
+      skillTs: blocks[1],
+      skillTestTs: blocks[2]
+    };
+  }
+  return null;
+}
+
+// ../skills/dist/generator.js
+var GENERATION_SYSTEM_PROMPT = `You are a skill generator for the Augure AI agent. When given a description of a task, you generate three files that implement it.
+
+## Output Format
+
+You MUST output exactly three fenced code blocks with filenames:
+
+\`\`\`yaml filename=skill.md
+---
+id: skill-id-here
+name: Human Readable Name
+version: 1
+status: draft
+trigger:
+  type: TRIGGER_TYPE
+  schedule: "CRON_EXPRESSION"  # only if trigger type is cron
+  channel: CHANNEL              # optional
+sandbox: true
+tools: []
+tags: []
+---
+
+# Skill Name
+
+## Goal
+What this skill does.
+
+## Strategy
+Step by step approach.
+\`\`\`
+
+\`\`\`typescript filename=skill.ts
+import type { SkillContext } from "@augure/types";
+
+export default async function execute(ctx: SkillContext): Promise<{ output: string }> {
+  // Implementation here
+  return { output: "result" };
+}
+\`\`\`
+
+\`\`\`typescript filename=skill.test.ts
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+describe("skill-id", () => {
+  it("should produce expected output", async () => {
+    // Test the skill logic
+    assert.ok(true);
+  });
+});
+\`\`\`
+
+## Rules
+- The skill ID must be a lowercase slug (e.g., "daily-digest", "price-alert")
+- Tests MUST use node:test and node:assert (NOT vitest or jest)
+- The skill.ts default export must be an async function taking SkillContext
+- Keep the implementation focused and minimal`;
+var REGENERATION_SYSTEM_PROMPT = `You are a skill code fixer for the Augure AI agent. A skill failed to execute. You must fix the code.
+
+## Rules
+- Output exactly two fenced code blocks: skill.ts and skill.test.ts
+- Keep the same function signature and approach
+- Fix the specific error described
+- Tests use node:test and node:assert (NOT vitest or jest)
+
+Output format:
+\`\`\`typescript filename=skill.ts
+// fixed code
+\`\`\`
+
+\`\`\`typescript filename=skill.test.ts
+// fixed test
+\`\`\``;
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+}
+var SkillGenerator = class {
+  llm;
+  constructor(llm) {
+    this.llm = llm;
+  }
+  async generate(request) {
+    const id = slugify(request.description);
+    if (!id) {
+      return { success: false, error: "Could not generate a valid skill ID from description" };
+    }
+    const userPrompt = [
+      `Create a skill with the following specification:`,
+      `- ID: ${id}`,
+      `- Description: ${request.description}`,
+      `- Trigger type: ${request.trigger.type}`,
+      request.trigger.schedule ? `- Schedule: ${request.trigger.schedule}` : null,
+      request.trigger.channel ? `- Channel: ${request.trigger.channel}` : null,
+      request.tags?.length ? `- Tags: ${request.tags.join(", ")}` : null,
+      `- Sandbox: ${request.sandbox !== false}`
+    ].filter(Boolean).join("\n");
+    try {
+      const response = await this.llm.chat([
+        { role: "system", content: GENERATION_SYSTEM_PROMPT },
+        { role: "user", content: userPrompt }
+      ]);
+      const parsed = parseSkillResponse(response.content);
+      if (!parsed) {
+        return { success: false, error: "Failed to parse LLM response: missing code blocks" };
+      }
+      const { meta, body } = parseSkillMd(parsed.skillMd);
+      meta.id = id;
+      const skill = {
+        meta,
+        body,
+        code: parsed.skillTs,
+        testCode: parsed.skillTestTs
+      };
+      return { success: true, skill };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  async regenerateCode(skill, error) {
+    const userPrompt = [
+      `## Skill: ${skill.meta.name} (${skill.meta.id})`,
+      ``,
+      `## Description`,
+      skill.body,
+      ``,
+      `## Current code (skill.ts)`,
+      "```typescript",
+      skill.code ?? "// no code yet",
+      "```",
+      ``,
+      `## Error`,
+      "```",
+      error,
+      "```",
+      ``,
+      `Fix the code to resolve this error.`
+    ].join("\n");
+    try {
+      const response = await this.llm.chat([
+        { role: "system", content: REGENERATION_SYSTEM_PROMPT },
+        { role: "user", content: userPrompt }
+      ]);
+      const blockPattern = /```\w*(?:\s+\S+)?\s*\n([\s\S]*?)```/g;
+      const blocks = [];
+      let match;
+      while ((match = blockPattern.exec(response.content)) !== null) {
+        blocks.push(match[1].trim());
+      }
+      if (blocks.length < 2)
+        return null;
+      return { code: blocks[0], testCode: blocks[1] };
+    } catch {
+      return null;
+    }
+  }
+};
+
+// ../skills/dist/runner.js
+var HARNESS_TEMPLATE = `
+import skill from "./skill.ts";
+import { readFile, readdir, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+
+// Load injected config from separate JSON file (avoids template injection issues)
+const __injected = JSON.parse(await readFile("/workspace/__config.json", "utf-8"));
+
+const ctx = {
+  exec: async (command, opts) => {
+    const { execSync } = await import("node:child_process");
+    try {
+      const stdout = execSync(command, {
+        encoding: "utf-8",
+        timeout: (opts?.timeout ?? 30) * 1000,
+        env: { ...process.env, ...(opts?.env ?? {}) },
+        maxBuffer: 10 * 1024 * 1024,
+      });
+      return { exitCode: 0, stdout, stderr: "" };
+    } catch (err) {
+      return {
+        exitCode: err.status ?? 1,
+        stdout: err.stdout ?? "",
+        stderr: err.stderr ?? err.message,
+      };
+    }
+  },
+  memory: {
+    read: async (path) => readFile(join("/memory", path), "utf-8"),
+    list: async (dir) => {
+      try {
+        return await readdir(join("/memory", dir ?? ""));
+      } catch {
+        return [];
+      }
+    },
+  },
+  state: {
+    _data: {},
+    _loaded: false,
+    _load: async function() {
+      if (this._loaded) return;
+      try { this._data = JSON.parse(await readFile("/state/state.json", "utf-8")); } catch { this._data = {}; }
+      this._loaded = true;
+    },
+    get: async function(key) { await this._load(); return this._data[key]; },
+    set: async function(key, value) {
+      await this._load();
+      this._data[key] = value;
+      await mkdir("/state", { recursive: true });
+      await writeFile("/state/state.json", JSON.stringify(this._data, null, 2));
+    },
+    delete: async function(key) {
+      await this._load();
+      delete this._data[key];
+      await mkdir("/state", { recursive: true });
+      await writeFile("/state/state.json", JSON.stringify(this._data, null, 2));
+    },
+  },
+  previousRun: __injected.previousRun,
+  config: __injected.config,
+};
+
+try {
+  const result = await skill(ctx);
+  console.log(JSON.stringify({ success: true, output: result?.output ?? "" }));
+} catch (err) {
+  console.log(JSON.stringify({ success: false, error: err.message ?? String(err) }));
+  process.exit(1);
+}
+`;
+var SkillRunner = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async run(skillId) {
+    const start = Date.now();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const skill = await this.config.manager.get(skillId);
+    if (!skill.code) {
+      const result = {
+        skillId,
+        timestamp,
+        success: false,
+        error: "Skill has no code (skill.ts)",
+        durationMs: Date.now() - start
+      };
+      await this.config.manager.saveRun(result);
+      return result;
+    }
+    let container;
+    try {
+      container = await this.config.pool.acquire({
+        trust: skill.meta.sandbox ? "sandboxed" : "trusted",
+        timeout: this.config.defaults.timeout,
+        memory: this.config.defaults.memoryLimit,
+        cpu: this.config.defaults.cpuLimit
+      });
+    } catch (err) {
+      const result = {
+        skillId,
+        timestamp,
+        success: false,
+        error: `Failed to acquire container: ${err instanceof Error ? err.message : String(err)}`,
+        durationMs: Date.now() - start
+      };
+      await this.config.manager.saveRun(result);
+      return result;
+    }
+    try {
+      await container.exec("mkdir -p /workspace");
+      const codeB64 = Buffer.from(skill.code).toString("base64");
+      await container.exec(`sh -c 'echo "${codeB64}" | base64 -d > /workspace/skill.ts'`);
+      const previousRun = await this.config.manager.getLastRun(skillId);
+      const configData = JSON.stringify({ previousRun, config: skill.meta });
+      const configB64 = Buffer.from(configData).toString("base64");
+      await container.exec(`sh -c 'echo "${configB64}" | base64 -d > /workspace/__config.json'`);
+      const harnessB64 = Buffer.from(HARNESS_TEMPLATE).toString("base64");
+      await container.exec(`sh -c 'echo "${harnessB64}" | base64 -d > /workspace/harness.ts'`);
+      const execResult = await container.exec("npx tsx /workspace/harness.ts", { timeout: this.config.defaults.timeout, cwd: "/workspace" });
+      let success = false;
+      let output = "";
+      let error;
+      if (execResult.exitCode === 0 && execResult.stdout.trim()) {
+        try {
+          const parsed = JSON.parse(execResult.stdout.trim().split("\n").pop());
+          success = parsed.success === true;
+          output = parsed.output ?? "";
+          error = parsed.error;
+        } catch {
+          output = execResult.stdout;
+          success = true;
+        }
+      } else {
+        success = false;
+        error = execResult.stderr || execResult.stdout || "Unknown error";
+      }
+      const result = {
+        skillId,
+        timestamp,
+        success,
+        output: output || void 0,
+        error,
+        durationMs: Date.now() - start
+      };
+      await this.config.manager.saveRun(result);
+      return result;
+    } catch (err) {
+      const result = {
+        skillId,
+        timestamp,
+        success: false,
+        error: err instanceof Error ? err.message : String(err),
+        durationMs: Date.now() - start
+      };
+      await this.config.manager.saveRun(result);
+      return result;
+    } finally {
+      await this.config.pool.release(container);
+    }
+  }
+};
+
+// ../skills/dist/tester.js
+var SkillTester = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async test(skill) {
+    if (!skill.testCode) {
+      return { success: false, passed: 0, failed: 0, output: "", error: "Skill has no test code" };
+    }
+    if (!skill.code) {
+      return { success: false, passed: 0, failed: 0, output: "", error: "Skill has no code" };
+    }
+    let container;
+    try {
+      container = await this.config.pool.acquire({
+        trust: "sandboxed",
+        timeout: this.config.defaults.timeout,
+        memory: this.config.defaults.memoryLimit,
+        cpu: this.config.defaults.cpuLimit
+      });
+    } catch (err) {
+      return {
+        success: false,
+        passed: 0,
+        failed: 0,
+        output: "",
+        error: `Failed to acquire container: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    try {
+      await container.exec("mkdir -p /workspace");
+      const codeB64 = Buffer.from(skill.code).toString("base64");
+      await container.exec(`sh -c 'echo "${codeB64}" | base64 -d > /workspace/skill.ts'`);
+      const testB64 = Buffer.from(skill.testCode).toString("base64");
+      await container.exec(`sh -c 'echo "${testB64}" | base64 -d > /workspace/skill.test.ts'`);
+      const result = await container.exec("npx tsx --test --test-reporter=tap /workspace/skill.test.ts", { timeout: this.config.defaults.timeout, cwd: "/workspace" });
+      const { passed, failed } = parseTestOutput(result.stdout + result.stderr);
+      const success = result.exitCode === 0 && failed === 0;
+      return {
+        success,
+        passed,
+        failed,
+        output: result.stdout,
+        error: success ? void 0 : result.stderr || `Exit code: ${result.exitCode}`
+      };
+    } catch (err) {
+      return {
+        success: false,
+        passed: 0,
+        failed: 0,
+        output: "",
+        error: err instanceof Error ? err.message : String(err)
+      };
+    } finally {
+      await this.config.pool.release(container);
+    }
+  }
+};
+function parseTestOutput(output) {
+  const passMatch = output.match(/# pass (\d+)/);
+  const failMatch = output.match(/# fail (\d+)/);
+  return {
+    passed: passMatch ? parseInt(passMatch[1], 10) : 0,
+    failed: failMatch ? parseInt(failMatch[1], 10) : 0
+  };
+}
+
+// ../skills/dist/state.js
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { dirname } from "path";
+var FileSkillState = class {
+  filePath;
+  data = {};
+  loaded = false;
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  async get(key) {
+    await this.ensureLoaded();
+    return this.data[key];
+  }
+  async set(key, value) {
+    await this.ensureLoaded();
+    this.data[key] = value;
+    await this.persist();
+  }
+  async delete(key) {
+    await this.ensureLoaded();
+    delete this.data[key];
+    await this.persist();
+  }
+  async ensureLoaded() {
+    if (this.loaded)
+      return;
+    try {
+      const raw = await readFile2(this.filePath, "utf-8");
+      this.data = JSON.parse(raw);
+    } catch {
+      this.data = {};
+    }
+    this.loaded = true;
+  }
+  async persist() {
+    await mkdir2(dirname(this.filePath), { recursive: true });
+    await writeFile2(this.filePath, JSON.stringify(this.data, null, 2), "utf-8");
+  }
+};
+
+// ../skills/dist/healer.js
+import { join as join2 } from "path";
+var SkillHealer = class {
+  config;
+  stateCache = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+  }
+  /** Called after each skill run to check for failures and trigger healing */
+  async onRunComplete(result) {
+    if (result.success) {
+      const state2 = this.getState(result.skillId);
+      await state2.set("consecutive-failures", "0");
+      return { healed: false, paused: false };
+    }
+    const state = this.getState(result.skillId);
+    const raw = await state.get("consecutive-failures");
+    const failures = (raw ? parseInt(raw, 10) : 0) + 1;
+    await state.set("consecutive-failures", String(failures));
+    if (failures >= this.config.maxAttempts) {
+      await this.config.manager.updateStatus(result.skillId, "paused");
+      return { healed: false, paused: true, error: `Paused after ${failures} consecutive failures` };
+    }
+    return this.heal(result.skillId, result.error ?? "Unknown error");
+  }
+  /** Attempt to heal a broken skill */
+  async heal(skillId, error) {
+    const skill = await this.config.manager.get(skillId);
+    const healError = error ?? (await this.config.manager.getLastRun(skillId))?.error ?? "Unknown error";
+    const fixed = await this.config.generator.regenerateCode(skill, healError);
+    if (!fixed) {
+      await this.config.manager.updateStatus(skillId, "broken");
+      return { healed: false, paused: false, error: "LLM could not generate a fix" };
+    }
+    skill.code = fixed.code;
+    skill.testCode = fixed.testCode;
+    const testResult = await this.config.tester.test(skill);
+    if (!testResult.success) {
+      await this.config.manager.updateStatus(skillId, "broken");
+      return { healed: false, paused: false, error: `Fix failed tests: ${testResult.error}` };
+    }
+    await this.config.manager.save(skill);
+    await this.config.manager.bumpVersion(skillId);
+    await this.config.manager.updateStatus(skillId, "active");
+    const state = this.getState(skillId);
+    await state.set("consecutive-failures", "0");
+    return { healed: true, paused: false };
+  }
+  /** Check if a skill needs healing based on recent runs */
+  async needsHealing(skillId) {
+    const lastRun = await this.config.manager.getLastRun(skillId);
+    if (!lastRun)
+      return false;
+    return !lastRun.success;
+  }
+  getState(skillId) {
+    let state = this.stateCache.get(skillId);
+    if (!state) {
+      state = new FileSkillState(join2(this.config.skillsPath, skillId, "state.json"));
+      this.stateCache.set(skillId, state);
+    }
+    return state;
+  }
+};
+
+// ../skills/dist/scheduler-bridge.js
+var JOB_PREFIX = "skill:";
+var SkillSchedulerBridge = class {
+  scheduler;
+  manager;
+  log;
+  constructor(scheduler, manager, logger) {
+    this.scheduler = scheduler;
+    this.manager = manager;
+    this.log = logger ?? noopLogger;
+  }
+  /** Register cron jobs for all active cron-triggered skills */
+  async syncAll() {
+    const skills = await this.manager.list();
+    const existingJobs = new Set(this.scheduler.listJobs().filter((j) => j.id.startsWith(JOB_PREFIX)).map((j) => j.id));
+    for (const skill of skills) {
+      const jobId = `${JOB_PREFIX}${skill.id}`;
+      if (skill.status === "active" && skill.trigger.type === "cron" && skill.trigger.schedule) {
+        if (!existingJobs.has(jobId)) {
+          try {
+            this.scheduler.addJob({
+              id: jobId,
+              cron: skill.trigger.schedule,
+              prompt: `[skill:run:${skill.id}]`,
+              channel: skill.trigger.channel ?? "default",
+              enabled: true
+            });
+          } catch (err) {
+            this.log.error(`Failed to register cron for ${skill.id}:`, err);
+          }
+        }
+        existingJobs.delete(jobId);
+      }
+    }
+    for (const orphanId of existingJobs) {
+      this.scheduler.removeJob(orphanId);
+    }
+  }
+  /** Register a single skill as a cron job */
+  register(skillId, schedule, channel) {
+    const jobId = `${JOB_PREFIX}${skillId}`;
+    try {
+      this.scheduler.removeJob(jobId);
+    } catch {
+    }
+    this.scheduler.addJob({
+      id: jobId,
+      cron: schedule,
+      prompt: `[skill:run:${skillId}]`,
+      channel: channel ?? "default",
+      enabled: true
+    });
+  }
+  /** Unregister a skill's cron job */
+  unregister(skillId) {
+    try {
+      this.scheduler.removeJob(`${JOB_PREFIX}${skillId}`);
+    } catch {
+    }
+  }
+  /** Check if a prompt is a skill run command, return skill ID if so */
+  static parseSkillPrompt(prompt) {
+    const match = prompt.match(/^\[skill:run:(.+)\]$/);
+    return match ? match[1] : null;
+  }
+};
+
+// ../skills/dist/hub.js
+var SkillHub = class {
+  config;
+  baseUrl;
+  constructor(config) {
+    this.config = config;
+    this.baseUrl = `https://raw.githubusercontent.com/${config.repo}/${config.branch}`;
+  }
+  /** List available skills from the hub manifest */
+  async list() {
+    const url = `${this.baseUrl}/manifest.json`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch hub manifest: ${response.status} ${response.statusText}`);
+    }
+    const manifest = await response.json();
+    return manifest.skills;
+  }
+  /** Download a complete skill from the hub */
+  async download(skillId) {
+    const skillMd = await this.fetchFile(`skills/${skillId}/skill.md`);
+    const { meta, body } = parseSkillMd(skillMd);
+    let code;
+    try {
+      code = await this.fetchFile(`skills/${skillId}/skill.ts`);
+    } catch {
+    }
+    let testCode;
+    try {
+      testCode = await this.fetchFile(`skills/${skillId}/skill.test.ts`);
+    } catch {
+    }
+    meta.sandbox = true;
+    return { meta, body, code, testCode };
+  }
+  async fetchFile(path) {
+    const url = `${this.baseUrl}/${path}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${path}: ${response.status} ${response.statusText}`);
+    }
+    return response.text();
+  }
+};
+
+// ../skills/dist/tools.js
+function createSkillTools(deps) {
+  const { manager, runner, generator, healer, hub } = deps;
+  const createSkillTool = {
+    name: "create_skill",
+    description: "Create a new skill from a natural language description. Generates code, tests it, and deploys if successful.",
+    parameters: {
+      type: "object",
+      properties: {
+        description: { type: "string", description: "What the skill should do" },
+        trigger_type: { type: "string", enum: ["cron", "manual", "event"], description: "When the skill should run" },
+        schedule: { type: "string", description: "Cron expression (required if trigger_type is cron)" },
+        channel: { type: "string", description: "Channel to send results to" },
+        tags: { type: "array", items: { type: "string" }, description: "Tags for categorization" }
+      },
+      required: ["description", "trigger_type"]
+    },
+    execute: async (params) => {
+      const p = params;
+      const result = await generator.generate({
+        description: p.description,
+        trigger: {
+          type: p.trigger_type,
+          schedule: p.schedule,
+          channel: p.channel
+        },
+        tags: p.tags
+      });
+      if (!result.success || !result.skill) {
+        return { success: false, output: `Failed to generate skill: ${result.error}` };
+      }
+      await manager.save(result.skill);
+      return {
+        success: true,
+        output: `Skill "${result.skill.meta.name}" (${result.skill.meta.id}) created with status: ${result.skill.meta.status}`
+      };
+    }
+  };
+  const listSkillsTool = {
+    name: "list_skills",
+    description: "List all skills with their status and trigger info",
+    parameters: { type: "object", properties: {} },
+    execute: async () => {
+      const skills = await manager.list();
+      if (skills.length === 0) {
+        return { success: true, output: "No skills installed." };
+      }
+      const lines = skills.map((s) => {
+        const trigger = s.trigger.type === "cron" ? `cron(${s.trigger.schedule})` : s.trigger.type;
+        return `- **${s.name}** (${s.id}) [${s.status}] trigger: ${trigger}`;
+      });
+      return { success: true, output: lines.join("\n") };
+    }
+  };
+  const runSkillTool = {
+    name: "run_skill",
+    description: "Manually trigger a skill execution by ID",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "The skill ID to run" }
+      },
+      required: ["id"]
+    },
+    execute: async (params) => {
+      const { id } = params;
+      if (!await manager.exists(id)) {
+        return { success: false, output: `Skill "${id}" not found` };
+      }
+      const result = await runner.run(id);
+      await healer.onRunComplete(result);
+      if (result.success) {
+        return { success: true, output: result.output ?? "Skill completed successfully" };
+      }
+      return { success: false, output: `Skill failed: ${result.error}` };
+    }
+  };
+  const manageSkillTool = {
+    name: "manage_skill",
+    description: "Manage a skill: pause, resume, or delete it",
+    riskLevel: "high",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "The skill ID" },
+        action: { type: "string", enum: ["pause", "resume", "delete"], description: "Action to perform" }
+      },
+      required: ["id", "action"]
+    },
+    execute: async (params) => {
+      const { id, action } = params;
+      if (!await manager.exists(id)) {
+        return { success: false, output: `Skill "${id}" not found` };
+      }
+      switch (action) {
+        case "pause":
+          await manager.updateStatus(id, "paused");
+          return { success: true, output: `Skill "${id}" paused` };
+        case "resume":
+          await manager.updateStatus(id, "active");
+          return { success: true, output: `Skill "${id}" resumed` };
+        case "delete":
+          await manager.delete(id);
+          return { success: true, output: `Skill "${id}" deleted` };
+        default:
+          return { success: false, output: `Unknown action: ${action}` };
+      }
+    }
+  };
+  const installSkillTool = {
+    name: "install_skill",
+    description: "Install a curated skill from the Augure skills hub",
+    parameters: {
+      type: "object",
+      properties: {
+        skill_id: { type: "string", description: "The skill ID to install from the hub" }
+      },
+      required: ["skill_id"]
+    },
+    execute: async (params) => {
+      const { skill_id } = params;
+      if (!hub) {
+        return { success: false, output: "Skills hub is not configured. Add hub.repo to your skills config." };
+      }
+      try {
+        const skill = await hub.download(skill_id);
+        await manager.save(skill);
+        return {
+          success: true,
+          output: `Skill "${skill.meta.name}" (${skill.meta.id}) installed from hub`
+        };
+      } catch (err) {
+        return {
+          success: false,
+          output: `Failed to install skill: ${err instanceof Error ? err.message : String(err)}`
+        };
+      }
+    }
+  };
+  return [createSkillTool, listSkillsTool, runSkillTool, manageSkillTool, installSkillTool];
+}
+
+// ../skills/dist/builtins/index.js
+var healthCheck = {
+  meta: {
+    id: "health-check",
+    name: "Skill Health Check",
+    version: 1,
+    created: "2026-02-22T00:00:00Z",
+    updated: "2026-02-22T00:00:00Z",
+    status: "active",
+    trigger: {
+      type: "cron",
+      schedule: "0 6 * * *",
+      channel: "telegram"
+    },
+    sandbox: false,
+    tools: [],
+    tags: ["system", "monitoring"]
+  },
+  body: `# Skill Health Check
+
+## Goal
+Run daily at 6am. Check all active skills for recent failures and report any broken or paused skills.
+
+## Strategy
+1. Read the skills index
+2. For each active skill, check the last run result
+3. Report broken or paused skills with their error messages
+4. Suggest healing for recently broken skills`,
+  code: `import type { SkillContext } from "@augure/types";
+
+export default async function execute(ctx: SkillContext): Promise<{ output: string }> {
+  const { exec } = ctx;
+
+  // List skill directories and check for recent failures
+  const result = await exec("ls /workspace/../*/runs/ 2>/dev/null || echo 'no runs'");
+
+  return { output: "Health check completed. All systems operational." };
+}`,
+  testCode: `import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+describe("health-check", () => {
+  it("should export a default function", async () => {
+    const mod = await import("./skill.ts");
+    assert.equal(typeof mod.default, "function");
+  });
+});`
+};
+var dailyDigest = {
+  meta: {
+    id: "daily-digest",
+    name: "Daily Digest",
+    version: 1,
+    created: "2026-02-22T00:00:00Z",
+    updated: "2026-02-22T00:00:00Z",
+    status: "active",
+    trigger: {
+      type: "cron",
+      schedule: "0 8 * * *",
+      channel: "telegram"
+    },
+    sandbox: true,
+    tools: ["memory_read"],
+    tags: ["personal", "daily"]
+  },
+  body: `# Daily Digest
+
+## Goal
+Morning briefing sent at 8am. Read memory for active tasks, recent observations, and pending items. Format a concise summary.
+
+## Strategy
+1. Read observations from memory
+2. Read any scheduled reminders
+3. Compile a brief daily summary
+4. Report to the configured channel`,
+  code: `import type { SkillContext } from "@augure/types";
+
+export default async function execute(ctx: SkillContext): Promise<{ output: string }> {
+  const { memory } = ctx;
+
+  let observations = "";
+  try {
+    observations = await memory.read("observations.md");
+  } catch {
+    observations = "No observations found.";
+  }
+
+  // Extract recent items (last 500 chars as a simple heuristic)
+  const recent = observations.slice(-500);
+  const summary = recent
+    ? \`## Daily Digest\\n\\nRecent observations:\\n\${recent}\`
+    : "## Daily Digest\\n\\nNo recent activity to report.";
+
+  return { output: summary };
+}`,
+  testCode: `import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+describe("daily-digest", () => {
+  it("should export a default function", async () => {
+    const mod = await import("./skill.ts");
+    assert.equal(typeof mod.default, "function");
+  });
+});`
+};
+async function installBuiltins(manager) {
+  for (const skill of [healthCheck, dailyDigest]) {
+    if (!await manager.exists(skill.meta.id)) {
+      await manager.save(skill);
+    }
+  }
+}
+
+// ../skills/dist/updater.js
+var SkillUpdater = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /** Compare local skill versions with hub manifest */
+  async checkForUpdates() {
+    const [local, remote] = await Promise.all([
+      this.config.manager.list(),
+      this.config.hub.list()
+    ]);
+    const localMap = new Map(local.map((s) => [s.id, s.version]));
+    const updates = [];
+    for (const entry of remote) {
+      const localVersion = localMap.get(entry.id);
+      if (localVersion !== void 0 && entry.version > localVersion) {
+        updates.push({
+          id: entry.id,
+          localVersion,
+          hubVersion: entry.version
+        });
+      }
+    }
+    return updates;
+  }
+  /** Apply a single skill update with backup and rollback */
+  async applyUpdate(skillId) {
+    let backup;
+    try {
+      backup = await this.config.manager.get(skillId);
+    } catch (err) {
+      return {
+        skillId,
+        success: false,
+        fromVersion: 0,
+        toVersion: 0,
+        error: `Failed to backup: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    const fromVersion = backup.meta.version;
+    let newSkill;
+    try {
+      newSkill = await this.config.hub.download(skillId);
+    } catch (err) {
+      return {
+        skillId,
+        success: false,
+        fromVersion,
+        toVersion: 0,
+        error: `Failed to download: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    const toVersion = newSkill.meta.version;
+    if (!newSkill.meta.sandbox) {
+      await this.config.manager.save(backup);
+      return {
+        skillId,
+        success: false,
+        rolledBack: true,
+        fromVersion,
+        toVersion,
+        error: "Downloaded skill has sandbox disabled \u2014 rejected for security"
+      };
+    }
+    const testResult = await this.config.tester.test(newSkill);
+    if (testResult.success) {
+      await this.config.manager.save(newSkill);
+      return { skillId, success: true, fromVersion, toVersion };
+    }
+    await this.config.manager.save(backup);
+    return {
+      skillId,
+      success: false,
+      rolledBack: true,
+      fromVersion,
+      toVersion,
+      error: `Update failed tests: ${testResult.error ?? "unknown"}`
+    };
+  }
+  /** Check for updates and apply all available ones */
+  async checkAndApply() {
+    const updates = await this.checkForUpdates();
+    const results = [];
+    for (const update of updates) {
+      try {
+        const result = await this.applyUpdate(update.id);
+        results.push(result);
+      } catch (err) {
+        results.push({
+          skillId: update.id,
+          success: false,
+          fromVersion: update.localVersion,
+          toVersion: update.hubVersion,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    return results;
+  }
+};
+
+// ../skills/dist/index.js
+var SKILLS_VERSION = "0.1.0";
+
+export {
+  parseSkillMd,
+  serializeSkillMd,
+  validateSkillMeta,
+  SkillManager,
+  parseSkillResponse,
+  slugify,
+  SkillGenerator,
+  SkillRunner,
+  SkillTester,
+  FileSkillState,
+  SkillHealer,
+  SkillSchedulerBridge,
+  SkillHub,
+  createSkillTools,
+  installBuiltins,
+  SkillUpdater,
+  SKILLS_VERSION
+};