rahman-resources 1.13.2 → 1.13.3

package/bin/cli.js

@@ -869,8 +869,12 @@ async function installSkill(slug, target) {
   const dest = path.join(target, ".claude", "skills", slug);
   process.stdout.write(`  ${kleur.cyan(slug.padEnd(20))} ${kleur.dim(`→ .claude/skills/${slug}/`)} ... `);
   if (skill.source === "anthropics") {
-    const emitter = tiged(`${SKILLS_REPO}/${skill.path}`, { cache: false, force: true, verbose: false });
-    await emitter.clone(dest);
+    const source = `${SKILLS_REPO}/${skill.path}`;
+    await cloneWithRetry(
+      () => tiged(source, { cache: false, force: true, verbose: false }),
+      dest,
+      source,
+    );
   } else if (skill.source === "rahman") {
     // Future: ship rahman-authored skills inside this repo. For now, scaffold a stub.
     mkdirSync(dest, { recursive: true });
@@ -1372,14 +1376,49 @@ async function checkGhInstalled() {
 
 // ─── helpers ──────────────────────────────────────────────────────────────
 
+// tiged surfaces raw git/network errors with no recovery hint. Translate the
+// common failure modes into actionable messages, and retry once on transient
+// network errors before giving up.
+async function cloneWithRetry(makeEmitter, dest, source) {
+  for (let attempt = 1; attempt <= 2; attempt++) {
+    try {
+      await makeEmitter().clone(dest);
+      return;
+    } catch (err) {
+      const msg = String(err?.message ?? err);
+      const transient = /ETIMEDOUT|ECONNRESET|EAI_AGAIN|socket hang up|50[234]/i.test(msg);
+      if (transient && attempt === 1) continue; // one silent retry
+      if (/ENOTFOUND|EAI_AGAIN|ECONNREFUSED|ETIMEDOUT|ECONNRESET/i.test(msg)) {
+        throw new Error(
+          `Network error fetching ${source}: ${msg}\n  → check your internet connection and retry.`,
+        );
+      }
+      if (/could not find|not found|ENOENT|404/i.test(msg)) {
+        throw new Error(
+          `Could not fetch ${source}: ${msg}\n  → verify the slug exists (run 'list') and the repo/branch is public.`,
+        );
+      }
+      throw new Error(`Failed to fetch ${source}: ${msg}`);
+    }
+  }
+}
+
 async function pull(repoPath, dest) {
-  const emitter = tiged(`${REPO}/${repoPath}#${BRANCH}`, { cache: false, force: true, verbose: false });
-  await emitter.clone(dest);
+  const source = `${REPO}/${repoPath}#${BRANCH}`;
+  await cloneWithRetry(
+    () => tiged(source, { cache: false, force: true, verbose: false }),
+    dest,
+    source,
+  );
 }
 
 async function pullFromRepo(repo, subPath, branch, dest) {
-  const emitter = tiged(`${repo}/${subPath}#${branch}`, { cache: false, force: true, verbose: false });
-  await emitter.clone(dest);
+  const source = `${repo}/${subPath}#${branch}`;
+  await cloneWithRetry(
+    () => tiged(source, { cache: false, force: true, verbose: false }),
+    dest,
+    source,
+  );
 }
 
 function detectPM(target) {

package/lib/contract-tools.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from "vitest";
+import { defineSliceContract } from "./contract";
+
+const base = {
+  id: "foo",
+  version: "1.0.0",
+  requires: {},
+  provides: {},
+};
+
+describe("defineSliceContract — provides.tools (agentic surface)", () => {
+  it("accepts tool names prefixed with the slice id", () => {
+    expect(() =>
+      defineSliceContract({
+        ...base,
+        provides: { tools: ["foo.bar", "foo.baz.qux"] },
+      }),
+    ).not.toThrow();
+  });
+
+  it("rejects tool names not prefixed with the slice id", () => {
+    expect(() =>
+      defineSliceContract({
+        ...base,
+        provides: { tools: ["bar.baz"] },
+      }),
+    ).toThrow(/must be prefixed with "foo\."/);
+  });
+
+  it("rejects non-string / empty tool entries", () => {
+    expect(() =>
+      defineSliceContract({
+        ...base,
+        provides: { tools: [""] as string[] },
+      }),
+    ).toThrow(/non-empty strings/);
+  });
+
+  it("allows tools to be omitted (non-agentic slices)", () => {
+    expect(() => defineSliceContract({ ...base })).not.toThrow();
+  });
+
+  it("allows a conflict to reference a tool name", () => {
+    expect(() =>
+      defineSliceContract({
+        ...base,
+        provides: { tools: ["foo.bar"] },
+        conflicts: ["other:tools.foo.bar"],
+      }),
+    ).not.toThrow();
+  });
+});

package/lib/contract-types.ts

@@ -88,6 +88,14 @@ export interface SliceContractProvides {
   events?: string[];
   /** Public component exports — e.g. `["DokuCheckoutButton"]`. */
   components?: string[];
+  /**
+   * Fully-qualified AI tool names the slice exposes as a `ToolCollection`
+   * (`@/shared/agentic`) — e.g. `["image-editor.layer.add"]`. Every entry
+   * MUST be prefixed with the slice id so one agent can aggregate tools from
+   * many slices without collision. A slice is "agentic-ready" iff this is
+   * non-empty.
+   */
+  tools?: string[];
 }
 
 // ---------------------------------------------------------------------------

package/lib/contract-validate.ts

@@ -18,7 +18,7 @@ const KEBAB_CASE = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
 const SEMVER =
   /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
 const PREFIX = /^[a-z][a-z0-9_]*_$/;
-const CONFLICT = /^[a-z][a-z0-9-]*:(routes|hooks|tables|events|components)\.[A-Za-z0-9_\-\/]+$/;
+const CONFLICT = /^[a-z][a-z0-9-]*:(routes|hooks|tables|events|components|tools)\.[A-Za-z0-9_\-\/.]+$/;
 const PERMISSION = /^[^.]+\.[^.]+$/;
 
 // ---------------------------------------------------------------------------
@@ -131,6 +131,28 @@ export function validateGeneralization(c: SliceContract): void {
   }
 }
 
+export function validateTools(c: SliceContract): void {
+  const tools = c.provides.tools;
+  if (tools === undefined) return;
+  if (!Array.isArray(tools)) {
+    throw new Error(`defineSliceContract(${c.id}): provides.tools must be an array`);
+  }
+  for (const t of tools) {
+    if (typeof t !== "string" || t.length === 0) {
+      throw new Error(
+        `defineSliceContract(${c.id}): provides.tools entries must be non-empty strings`,
+      );
+    }
+    // Every tool name MUST be namespaced to the slice id so one agent can
+    // aggregate collections from many slices without collision.
+    if (!t.startsWith(`${c.id}.`)) {
+      throw new Error(
+        `defineSliceContract(${c.id}): provides.tools entry "${t}" must be prefixed with "${c.id}."`,
+      );
+    }
+  }
+}
+
 export function validateConflicts(c: SliceContract): void {
   if (!c.conflicts) return;
   if (!Array.isArray(c.conflicts)) {

package/lib/contract.ts

@@ -15,6 +15,7 @@ import {
   validateConvex,
   validateGeneralization,
   validateConflicts,
+  validateTools,
 } from "./contract-validate";
 
 // Re-export the full type surface so existing imports keep working.
@@ -62,5 +63,6 @@ export function defineSliceContract(c: SliceContract): SliceContract {
   validateConvex(c);
   validateGeneralization(c);
   validateConflicts(c);
+  validateTools(c);
   return c;
 }