@wrongstack/core 0.284.1 → 0.285.0

package/dist/skills/index.js

@@ -1,12 +1,3 @@
-import * as fs5 from 'fs/promises';
-import * as os from 'os';
-import * as path5 from 'path';
-import { Readable } from 'stream';
-import { pipeline } from 'stream/promises';
-import { createGunzip } from 'zlib';
-import { randomBytes } from 'crypto';
-import { spawn } from 'child_process';
-
 // src/skills/foreign-sources.ts
 var FOREIGN_SKILL_TOOLS = [
   { id: "agents", subdir: "skills" },
@@ -151,18 +142,31 @@ function validateSkillName(name, parentDirName) {
   }
   return errors;
 }
+
+// src/skills/github-fetcher.ts
+import * as fs2 from "node:fs/promises";
+import * as os from "node:os";
+import * as path2 from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createGunzip } from "node:zlib";
+
+// src/utils/atomic-write.ts
+import { randomBytes } from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 async function atomicWrite(targetPath, content, opts = {}) {
-  const dir = path5.dirname(targetPath);
-  await fs5.mkdir(dir, { recursive: true });
-  const tmp = path5.join(dir, `.${path5.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  const dir = path.dirname(targetPath);
+  await fs.mkdir(dir, { recursive: true });
+  const tmp = path.join(dir, `.${path.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
   try {
     if (typeof content === "string") {
-      await fs5.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+      await fs.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
     } else {
-      await fs5.writeFile(tmp, content, { flag: "wx" });
+      await fs.writeFile(tmp, content, { flag: "wx" });
     }
     try {
-      const fh = await fs5.open(tmp, "r+");
+      const fh = await fs.open(tmp, "r+");
       try {
         await fh.sync();
       } finally {
@@ -172,24 +176,24 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat3 = await fs5.stat(targetPath);
+      const stat3 = await fs.stat(targetPath);
       mode = stat3.mode & 511;
     } catch {
       mode = opts.mode;
     }
     if (mode !== void 0) {
-      await fs5.chmod(tmp, mode);
+      await fs.chmod(tmp, mode);
     }
     await renameWithRetry(tmp, targetPath);
     if (mode !== void 0 && process.platform === "win32") {
       try {
-        await fs5.chmod(targetPath, mode);
+        await fs.chmod(targetPath, mode);
       } catch {
       }
     }
   } catch (err) {
     try {
-      await fs5.unlink(tmp);
+      await fs.unlink(tmp);
     } catch {
     }
     throw err;
@@ -198,14 +202,14 @@ async function atomicWrite(targetPath, content, opts = {}) {
 var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
 async function renameWithRetry(from, to) {
   if (process.platform !== "win32") {
-    await fs5.rename(from, to);
+    await fs.rename(from, to);
     return;
   }
   const delays = [10, 25, 60, 120, 250];
   let lastErr;
   for (let i = 0; i <= delays.length; i++) {
     try {
-      await fs5.rename(from, to);
+      await fs.rename(from, to);
       return;
     } catch (err) {
       lastErr = err;
@@ -227,7 +231,7 @@ function toErrorMessage(err) {
 // src/utils/expect-defined.ts
 function expectDefined(value, label) {
   if (value === null || value === void 0) {
-    const err = new Error("Expected value to be defined");
+    const err = new Error(label ? `Expected ${label} to be defined` : "Expected value to be defined");
     err.name = "ExpectDefinedError";
     throw err;
   }
@@ -547,7 +551,7 @@ async function downloadGitHubTarball(parsed) {
       }
     });
   }
-  const tempDir = await fs5.mkdtemp(path5.join(os.tmpdir(), "wskill-"));
+  const tempDir = await fs2.mkdtemp(path2.join(os.tmpdir(), "wskill-"));
   try {
     if (!response.body) {
       throw new WrongStackError({
@@ -569,7 +573,7 @@ async function downloadGitHubTarball(parsed) {
     await extractTar(tarBuf, tempDir);
     return { tempDir };
   } catch (err) {
-    await fs5.rm(tempDir, { recursive: true, force: true }).catch(() => {
+    await fs2.rm(tempDir, { recursive: true, force: true }).catch(() => {
     });
     throw err;
   }
@@ -586,25 +590,25 @@ async function extractTar(buf, destDir) {
     const fullPath = prefix ? `${prefix}/${name}` : name;
     const relPath = stripTopDir(fullPath);
     if (relPath && relPath !== "." && relPath !== "..") {
-      const destPath = path5.join(destDir, relPath);
-      const resolvedDest = path5.resolve(destPath);
-      const resolvedRoot = path5.resolve(destDir);
-      if (resolvedDest !== resolvedRoot && !resolvedDest.startsWith(resolvedRoot + path5.sep)) {
+      const destPath = path2.join(destDir, relPath);
+      const resolvedDest = path2.resolve(destPath);
+      const resolvedRoot = path2.resolve(destDir);
+      if (resolvedDest !== resolvedRoot && !resolvedDest.startsWith(resolvedRoot + path2.sep)) {
         offset += 512 + Math.ceil(size / 512) * 512;
         continue;
       }
       if (typeflag === 53 || typeflag === 0) {
         if (relPath.endsWith("/") || typeflag === 53) {
-          await fs5.mkdir(destPath, { recursive: true });
+          await fs2.mkdir(destPath, { recursive: true });
         }
       }
       if ((typeflag === 48 || typeflag === 0 || typeflag === 0) && size > 0) {
-        const dir = path5.dirname(destPath);
-        await fs5.mkdir(dir, { recursive: true });
+        const dir = path2.dirname(destPath);
+        await fs2.mkdir(dir, { recursive: true });
         const dataStart = offset + 512;
         const dataEnd = dataStart + size;
         if (dataEnd > buf.length) break;
-        await fs5.writeFile(destPath, buf.subarray(dataStart, dataEnd));
+        await fs2.writeFile(destPath, buf.subarray(dataStart, dataEnd));
       }
     }
     offset += 512 + Math.ceil(size / 512) * 512;
@@ -622,6 +626,10 @@ function stripTopDir(p) {
   if (idx === -1) return "";
   return p.slice(idx + 1);
 }
+
+// src/skills/manifest-store.ts
+import * as fs3 from "node:fs/promises";
+import * as path3 from "node:path";
 var SkillManifestStore = class {
   manifestPath;
   cache;
@@ -631,7 +639,7 @@ var SkillManifestStore = class {
   async read() {
     if (this.cache) return this.cache;
     try {
-      const raw = await fs5.readFile(this.manifestPath, "utf8");
+      const raw = await fs3.readFile(this.manifestPath, "utf8");
       const data = JSON.parse(raw);
       if (!Array.isArray(data.skills)) {
         this.cache = { skills: [] };
@@ -644,8 +652,8 @@ var SkillManifestStore = class {
     return this.cache;
   }
   async write(data) {
-    const dir = path5.dirname(this.manifestPath);
-    await fs5.mkdir(dir, { recursive: true });
+    const dir = path3.dirname(this.manifestPath);
+    await fs3.mkdir(dir, { recursive: true });
     await atomicWrite(this.manifestPath, JSON.stringify(data, null, 2) + "\n");
     this.cache = data;
   }
@@ -831,6 +839,11 @@ function numField(rec, key) {
   }
   return void 0;
 }
+
+// src/skills/skill-generator.ts
+import { spawn } from "node:child_process";
+import * as fs4 from "node:fs/promises";
+import * as path4 from "node:path";
 async function validateSkillNameAvailable(name, loader) {
   const formatViolations = validateSkillName(name);
   const conflicts = loader ? (await loader.listEntries()).filter((e) => e.name === name) : [];
@@ -949,11 +962,11 @@ async function writeSkeletonSkill(skillsDir, body, opts = {}) {
       subsystem: "general"
     });
   }
-  const skillDir = path5.join(skillsDir, name);
-  const skillFile = path5.join(skillDir, "SKILL.md");
+  const skillDir = path4.join(skillsDir, name);
+  const skillFile = path4.join(skillDir, "SKILL.md");
   if (!opts.overwrite) {
     try {
-      await fs5.access(skillFile);
+      await fs4.access(skillFile);
       throw new WrongStackError({
         message: `A skill already exists at ${skillFile}. Use --force to overwrite.`,
         code: ERROR_CODES.VALIDATION_ERROR,
@@ -964,8 +977,8 @@ async function writeSkeletonSkill(skillsDir, body, opts = {}) {
       if (err instanceof WrongStackError) throw err;
     }
   }
-  await fs5.mkdir(skillDir, { recursive: true });
-  await fs5.writeFile(skillFile, body, "utf8");
+  await fs4.mkdir(skillDir, { recursive: true });
+  await fs4.writeFile(skillFile, body, "utf8");
   return skillFile;
 }
 function bodyLineAdvisory(body) {
@@ -1004,6 +1017,10 @@ function defaultEditor() {
   if (process.platform === "darwin") return "open";
   return void 0;
 }
+
+// src/skills/skill-installer.ts
+import * as fs5 from "node:fs/promises";
+import * as path5 from "node:path";
 var MAX_SKILL_FILE_SIZE = SKILL_LIMITS.MAX_SKILL_FILE_SIZE;
 var SkillInstaller = class {
   opts;
@@ -1452,7 +1469,28 @@ function dedupeSearchResults(perAdapter) {
   }
   return out;
 }
-
-export { DEFAULT_SKILLS_SH_URL, FOREIGN_SKILL_TOOLS, SKILL_LIMITS, SkillInstaller, SkillManifestStore, bodyLineAdvisory, createSkillsShAdapter, downloadGitHubTarball, extractSkillFromPrompt, generateSkillSkeleton, githubDirectAdapter, isValidSkillNameFormat, openInEditor, parseSkillFrontmatter, parseSkillRef, resolveForeignToolIds, resolveForeignToolIdsWithWarnings, securityScoreToTier, stripFrontmatter, validateSkillName, validateSkillNameAvailable, writeSkeletonSkill };
+export {
+  DEFAULT_SKILLS_SH_URL,
+  FOREIGN_SKILL_TOOLS,
+  SKILL_LIMITS,
+  SkillInstaller,
+  SkillManifestStore,
+  bodyLineAdvisory,
+  createSkillsShAdapter,
+  downloadGitHubTarball,
+  extractSkillFromPrompt,
+  generateSkillSkeleton,
+  githubDirectAdapter,
+  isValidSkillNameFormat,
+  openInEditor,
+  parseSkillFrontmatter,
+  parseSkillRef,
+  resolveForeignToolIds,
+  resolveForeignToolIdsWithWarnings,
+  securityScoreToTier,
+  stripFrontmatter,
+  validateSkillName,
+  validateSkillNameAvailable,
+  writeSkeletonSkill
+};
 //# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map