tarsk 0.6.87 → 0.6.89

package/dist/bundled-skills/tarsk-tasks/scripts/tasks.js

@@ -0,0 +1,96 @@
+/**
+ * tasks — ok/error JSON copy in the Skill; host owns DB + launch.
+ */
+
+export const description =
+  "Project tasks. add/schedule: title+description required; optional tags, skillRef, trigger. list: id/title/status/tags, hides Done; filter query/status/tags. get: full task. tags: vocabulary+counts. update any field (null clears trigger/skill). implement this chat; runNow new thread (scheduled/event only). delete. Target by id or unique reference. Truncated ids resolve when unique. Skills load only at run.";
+
+export const parameters = {
+  type: "object",
+  required: ["action"],
+  properties: {
+    action: {
+      anyOf: [
+        { const: "add", type: "string" },
+        { const: "schedule", type: "string" },
+        { const: "list", type: "string" },
+        { const: "get", type: "string" },
+        { const: "tags", type: "string" },
+        { const: "update", type: "string" },
+        { const: "implement", type: "string" },
+        { const: "runNow", type: "string" },
+        { const: "delete", type: "string" },
+      ],
+    },
+    description: { type: "string" },
+    title: { type: "string" },
+    query: {
+      description: "list: title/description substring",
+      type: "string",
+    },
+    status: {
+      anyOf: [
+        { const: "Ready", type: "string" },
+        { const: "Plan", type: "string" },
+        { const: "Build", type: "string" },
+        { const: "Test", type: "string" },
+        { const: "Review", type: "string" },
+        { const: "Done", type: "string" },
+      ],
+    },
+    id: { type: "string" },
+    reference: {
+      description: "unique title/ticket, e.g. oc-2",
+      type: "string",
+    },
+    tags: {
+      description:
+        "set on write; AND-filter on list; prefer existing tags via the tags action; create a new tag only when the user explicitly asks; max 10 tags, 40 chars",
+      type: "array",
+      items: { type: "string" },
+    },
+    triggerType: {
+      description: "null clears",
+      anyOf: [
+        { const: "schedule", type: "string" },
+        { const: "event", type: "string" },
+        { type: "null" },
+      ],
+    },
+    scheduledAt: {
+      description: "ISO one-shot",
+      anyOf: [{ type: "string" }, { type: "null" }],
+    },
+    scheduleCron: {
+      description: "cron",
+      anyOf: [{ type: "string" }, { type: "null" }],
+    },
+    timezone: {
+      anyOf: [{ type: "string" }, { type: "null" }],
+    },
+    enabled: { type: "boolean" },
+    skillRef: {
+      description: "//bundled or /project-or-global",
+      anyOf: [{ type: "string" }, { type: "null" }],
+    },
+    eventKey: {
+      description: "required for event",
+      anyOf: [{ type: "string" }, { type: "null" }],
+    },
+  },
+};
+
+/** @param {Record<string, unknown>} args @param {import("../../../../src/tools/agent-runtime/types.js").AgentRuntime} context */
+export async function execute(args, context) {
+  const result = await context.tasks.query(args);
+  if (!result.ok) {
+    return {
+      content: [{ type: "text", text: result.error }],
+      details: undefined,
+    };
+  }
+  return {
+    content: [{ type: "text", text: JSON.stringify(result.data) }],
+    details: undefined,
+  };
+}

package/dist/bundled-skills/tarsk-todo/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: tarsk-todo
+description: >-
+  Tarsk Tool skill publishing: todo.
+version: 2.0.0
+tools:
+  - todo
+disable-model-invocation: true
+---
+
+# tarsk-todo
+
+Publishes: todo.
+
+Logic and formatting live in `scripts/todo.js`. Persistence and progress.txt
+are `context.todos` (CLI host).

package/dist/bundled-skills/tarsk-todo/scripts/todo.js

@@ -0,0 +1,165 @@
+/**
+ * todo — formatting and action policy in the Skill; store via context.todos (host).
+ */
+
+export const description =
+  "Break work into todos (~2 when planning). Actions: add (descriptions), update/delete (ids), list, learnings. Status pending→working→done. Mark each item done as soon as that work is finished. Do not send the final reply while any todo is pending or working. Mark verify/check todos done only after checks pass. Optional Goal Round bookkeeping: passes=true once an item's work is verified; learnings appends progress.txt. list = full checklist; update/delete = short ack plus remaining incomplete items.";
+
+export const parameters = {
+  type: "object",
+  required: ["action"],
+  properties: {
+    action: {
+      anyOf: [
+        { const: "add", type: "string" },
+        { const: "update", type: "string" },
+        { const: "list", type: "string" },
+        { const: "delete", type: "string" },
+        { const: "learnings", type: "string" },
+      ],
+    },
+    descriptions: {
+      description: "required for add",
+      type: "array",
+      items: { type: "string" },
+    },
+    ids: {
+      description: "required for update/delete",
+      type: "array",
+      items: { type: "string" },
+    },
+    status: {
+      anyOf: [
+        { const: "pending", type: "string" },
+        { const: "working", type: "string" },
+        { const: "done", type: "string" },
+      ],
+    },
+    assignedTo: { type: "string" },
+    passes: {
+      description: "true once this item's work is verified",
+      type: "boolean",
+    },
+    learnings: {
+      description: "required for learnings; appends progress.txt",
+      type: "string",
+    },
+  },
+};
+
+const ADD_TODOS_NOTE =
+  "Mark each item done as you finish it. Do not end the turn with pending todos.";
+
+function textResult(text, details) {
+  return { content: [{ type: "text", text }], details };
+}
+
+function truncateTodoDescription(description, maxLength = 48) {
+  const oneLine = String(description).replace(/\s+/g, " ").trim();
+  if (oneLine.length <= maxLength) return oneLine;
+  return `${oneLine.slice(0, maxLength - 1)}…`;
+}
+
+function formatUpdatedTodosAck(items) {
+  if (items.length === 1) {
+    const item = items[0];
+    return `Updated 1 todo: "${truncateTodoDescription(item.description)}" → ${item.status}`;
+  }
+  const parts = items.map(
+    (item) => `"${truncateTodoDescription(item.description)}" → ${item.status}`,
+  );
+  return `Updated ${items.length} todos: ${parts.join("; ")}`;
+}
+
+function formatDeletedTodosAck(items) {
+  if (items.length === 1) {
+    return `Deleted 1 todo: "${truncateTodoDescription(items[0].description)}"`;
+  }
+  const parts = items.map((item) => `"${truncateTodoDescription(item.description)}"`);
+  return `Deleted ${items.length} todos: ${parts.join("; ")}`;
+}
+
+function formatRemainingTodosSuffix(todos) {
+  const remaining = todos
+    .filter((todo) => todo.status !== "done")
+    .map((todo) => ({
+      id: todo.id,
+      description: todo.description,
+      status: todo.status,
+    }));
+  if (remaining.length === 0) {
+    return "All todos complete.";
+  }
+  return `Remaining: ${JSON.stringify(remaining)}`;
+}
+
+function formatTodoMutationResult(ack, todos) {
+  return `${ack} ${formatRemainingTodosSuffix(todos)}`;
+}
+
+/** @param {Record<string, unknown>} args @param {import("../../../../src/tools/agent-runtime/types.js").AgentRuntime} context */
+export async function execute(args, context) {
+  const action = args.action;
+
+  if (action === "add") {
+    const descriptions = Array.isArray(args.descriptions)
+      ? args.descriptions.map(String).filter((d) => d.trim())
+      : [];
+    if (descriptions.length === 0) {
+      return textResult("Error: descriptions is required for 'add'");
+    }
+    const assignedTo = typeof args.assignedTo === "string" ? args.assignedTo : undefined;
+    const todos = await context.todos.add(descriptions, assignedTo);
+    return textResult(JSON.stringify({ todos, note: ADD_TODOS_NOTE }), { todos });
+  }
+
+  if (action === "update") {
+    const ids = Array.isArray(args.ids) ? args.ids.map(String) : [];
+    if (ids.length === 0) {
+      return textResult("Error: ids is required for 'update'");
+    }
+    const result = await context.todos.update(ids, {
+      status: typeof args.status === "string" ? args.status : undefined,
+      assignedTo: typeof args.assignedTo === "string" ? args.assignedTo : undefined,
+      passes: typeof args.passes === "boolean" ? args.passes : undefined,
+    });
+    if ("error" in result) {
+      return textResult(`Error: ${result.error}`);
+    }
+    return textResult(
+      formatTodoMutationResult(formatUpdatedTodosAck(result.updated), result.todos),
+      { todos: result.todos },
+    );
+  }
+
+  if (action === "list") {
+    const todos = await context.todos.list();
+    return textResult(JSON.stringify({ todos }), { todos });
+  }
+
+  if (action === "delete") {
+    const ids = Array.isArray(args.ids) ? args.ids.map(String) : [];
+    if (ids.length === 0) {
+      return textResult("Error: ids is required for 'delete'");
+    }
+    const result = await context.todos.remove(ids);
+    return textResult(
+      formatTodoMutationResult(formatDeletedTodosAck(result.deleted), result.todos),
+      { todos: result.todos },
+    );
+  }
+
+  if (action === "learnings") {
+    const learnings = typeof args.learnings === "string" ? args.learnings.trim() : "";
+    if (!learnings) {
+      return textResult("Error: learnings text is required for 'learnings' action");
+    }
+    const result = await context.todos.appendLearnings(learnings);
+    if ("error" in result) {
+      return textResult(`Error: ${result.error}`);
+    }
+    return textResult("Learnings appended to progress.txt successfully.");
+  }
+
+  return textResult(`Unknown action: ${String(action)}`);
+}

package/dist/bundled-skills/tarsk-web-search/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: tarsk-web-search
+description: >-
+  Tarsk Tool skill publishing: web_search.
+version: 2.0.0
+tools:
+  - web_search
+deferred-tools:
+  - web_search
+disable-model-invocation: true
+---
+
+# tarsk-web-search
+
+Publishes: web_search.

package/dist/bundled-skills/tarsk-web-search/scripts/web_search.js

@@ -0,0 +1,120 @@
+/**
+ * web_search Tool — logic lives here; network client is context.web (host).
+ */
+
+export const description =
+  "Search the web for current information, documentation, API references, and code examples. " +
+  "Returns titles, URLs, and query-relevant highlights for each result. " +
+  "Use fetch to read a specific URL in full after finding it.";
+
+export const parameters = {
+  type: "object",
+  required: ["query"],
+  properties: {
+    query: {
+      description:
+        "Natural language search query (e.g. 'Next.js route handler authentication example')",
+      type: "string",
+    },
+    numResults: {
+      description: "Results to return (1-100, default 10)",
+      minimum: 1,
+      maximum: 100,
+      type: "number",
+    },
+    type: {
+      description:
+        "Search depth/latency tradeoff. Use auto (default) for most queries; fast/instant for low latency; deep variants for research.",
+      anyOf: [
+        { const: "auto", type: "string" },
+        { const: "fast", type: "string" },
+        { const: "instant", type: "string" },
+        { const: "deep-lite", type: "string" },
+        { const: "deep", type: "string" },
+        { const: "deep-reasoning", type: "string" },
+      ],
+    },
+    includeDomains: {
+      description:
+        "Only return results from these domains (e.g. ['docs.github.com', 'nodejs.org'])",
+      type: "array",
+      items: { type: "string" },
+    },
+    excludeDomains: {
+      description: "Domains to exclude",
+      type: "array",
+      items: { type: "string" },
+    },
+  },
+};
+
+/** @param {Record<string, unknown>} args @param {import("../../../../src/tools/agent-runtime/types.js").AgentRuntime} context */
+export async function execute(args, context, options) {
+  const query = String(args.query ?? "");
+  const numResults = typeof args.numResults === "number" ? args.numResults : undefined;
+  const type = typeof args.type === "string" ? args.type : undefined;
+  const includeDomains = Array.isArray(args.includeDomains) ? args.includeDomains : undefined;
+  const excludeDomains = Array.isArray(args.excludeDomains) ? args.excludeDomains : undefined;
+
+  return context.util.withAbort(options?.signal, async function runSearch(isAborted) {
+    options?.onUpdate?.({
+      content: [{ type: "text", text: `Searching the web for "${query}"…` }],
+      details: undefined,
+    });
+
+    let response;
+    try {
+      response = await context.web.search({
+        query,
+        numResults,
+        type,
+        includeDomains,
+        excludeDomains,
+        signal: options?.signal,
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text", text: message }],
+        details: undefined,
+      };
+    }
+
+    if (isAborted()) {
+      return { content: [], details: undefined };
+    }
+
+    const payload = {
+      query,
+      searchType: response.searchType ?? type ?? "auto",
+      requestId: response.requestId,
+      resultCount: response.results.length,
+      results: response.results.map(function mapResult(result) {
+        return {
+          title: result.title,
+          url: result.url,
+          publishedDate: result.publishedDate ?? undefined,
+          author: result.author ?? undefined,
+          highlights: result.highlights ?? [],
+        };
+      }),
+    };
+
+    const serialized = JSON.stringify(payload, null, 2);
+    const truncated = context.util.truncateHead(serialized, { maxLines: 500, maxBytes: 50 * 1024 });
+    let output = truncated.content;
+    if (truncated.truncated) {
+      output += `\n\n[Output truncated: showing ${truncated.outputLines}/${truncated.totalLines} lines]`;
+    }
+
+    return {
+      content: [{ type: "text", text: output }],
+      details: {
+        query,
+        searchType: payload.searchType,
+        resultCount: payload.resultCount,
+        requestId: response.requestId,
+      },
+    };
+  });
+}

package/dist/bundled-skills/tarsk-write/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: tarsk-write
+description: >-
+  Tarsk Tool skill publishing: write.
+version: 3.0.0
+tools:
+  - write
+disable-model-invocation: true
+---
+
+# tarsk-write
+
+Publishes: write.
+
+Messaging lives in `scripts/write.js`. Secure write (cwd check, parents,
+mutation tracking) is `context.fs.writeText`.

package/dist/bundled-skills/tarsk-write/scripts/write.js

@@ -0,0 +1,57 @@
+/**
+ * write — messaging in the Skill; secure write via context.fs (host).
+ */
+
+export const description =
+  "Write a new file or overwrite an existing one (creates parent directories). Prefer edit for existing files; use write for new files or intentional full rewrites. Overwrites report previous → new byte counts.";
+
+export const parameters = {
+  type: "object",
+  required: ["path", "content"],
+  properties: {
+    path: {
+      description: "File path (relative or absolute)",
+      type: "string",
+    },
+    content: {
+      description: "Content to write",
+      type: "string",
+    },
+  },
+};
+
+function formatWriteResult(path, previousBytes, nextBytes, syntaxDiagnostics) {
+  let text;
+  if (previousBytes === null) {
+    text = `Created ${path} (${nextBytes} bytes).`;
+  } else {
+    text =
+      `Overwrote existing ${path} (${previousBytes} → ${nextBytes} bytes). ` +
+      `Prefer edit for existing files unless this is an intentional full rewrite.`;
+  }
+  if (syntaxDiagnostics) {
+    text = `${text}\n\n${syntaxDiagnostics}`;
+  }
+  return text;
+}
+
+/** @param {Record<string, unknown>} args @param {import("../../../../src/tools/agent-runtime/types.js").AgentRuntime} context @param {{ signal?: AbortSignal }} [options] */
+export async function execute(args, context, options) {
+  const path = String(args.path ?? "");
+  const content = String(args.content ?? "");
+  const result = await context.fs.writeText(path, content, { signal: options?.signal });
+  return {
+    content: [
+      {
+        type: "text",
+        text: formatWriteResult(
+          result.path,
+          result.previousBytes,
+          result.nextBytes,
+          result.syntaxDiagnostics,
+        ),
+      },
+    ],
+    details: { supersession: result.supersession },
+  };
+}