@weave-tools/weave-it 0.1.0 → 0.1.2

package/dist/cli.d.ts

@@ -1,5 +1,7 @@
 import { Command } from 'commander';
 
+declare function readPackageVersion(moduleUrl?: string): string;
 declare function createProgram(): Command;
+declare function isDirectCliInvocation(scriptPath?: string, moduleUrl?: string): boolean;
 
-export { createProgram };
+export { createProgram, isDirectCliInvocation, readPackageVersion };

package/dist/cli.js

@@ -18,60 +18,60 @@ import { realpath } from "fs/promises";
 import { constants } from "fs";
 import { access, mkdir, readFile, readdir, rename, stat, writeFile } from "fs/promises";
 import { dirname } from "path";
-async function pathExists(path14) {
+async function pathExists(path15) {
   try {
-    await access(path14, constants.F_OK);
+    await access(path15, constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
-async function writeNewFile(path14, contents) {
-  await writeFile(path14, contents, { flag: "wx" });
+async function writeNewFile(path15, contents) {
+  await writeFile(path15, contents, { flag: "wx" });
 }
-async function writeFileIfMissing(path14, contents) {
-  if (await pathExists(path14)) {
+async function writeFileIfMissing(path15, contents) {
+  if (await pathExists(path15)) {
     return false;
   }
-  await writeNewFile(path14, contents);
+  await writeNewFile(path15, contents);
   return true;
 }
-async function writeFileAtomic(path14, contents) {
-  const tempPath = `${path14}.${process.pid}.tmp`;
+async function writeFileAtomic(path15, contents) {
+  const tempPath = `${path15}.${process.pid}.tmp`;
   await writeFile(tempPath, contents);
-  await rename(tempPath, path14);
+  await rename(tempPath, path15);
 }
-async function ensureDir(path14) {
-  await mkdir(path14, { recursive: true });
+async function ensureDir(path15) {
+  await mkdir(path15, { recursive: true });
 }
-async function createDirExclusive(path14) {
-  await mkdir(path14, { recursive: false });
+async function createDirExclusive(path15) {
+  await mkdir(path15, { recursive: false });
 }
-async function ensureDirectory(path14) {
-  const value = await stat(path14);
+async function ensureDirectory(path15) {
+  const value = await stat(path15);
   if (!value.isDirectory()) {
-    throw new Error(`Expected a directory: ${path14}`);
+    throw new Error(`Expected a directory: ${path15}`);
   }
 }
-async function isDirectoryEmpty(path14) {
-  const entries = await readdir(path14);
+async function isDirectoryEmpty(path15) {
+  const entries = await readdir(path15);
   return entries.length === 0;
 }
 async function movePath(source, target) {
   await rename(source, target);
 }
-async function readJsonCache(path14) {
+async function readJsonCache(path15) {
   try {
-    const contents = await readFile(path14, "utf8");
+    const contents = await readFile(path15, "utf8");
     return JSON.parse(contents);
   } catch {
     return null;
   }
 }
-async function writeJsonCache(path14, data) {
+async function writeJsonCache(path15, data) {
   try {
-    await mkdir(dirname(path14), { recursive: true });
-    await writeFileAtomic(path14, JSON.stringify(data, null, 2));
+    await mkdir(dirname(path15), { recursive: true });
+    await writeFileAtomic(path15, JSON.stringify(data, null, 2));
     return true;
   } catch {
     return false;
@@ -1274,8 +1274,8 @@ function formatFullFileDiff(installedPath, defaultName, installed, currentDefaul
 function splitLines(value) {
   return value.endsWith("\n") ? value.slice(0, -1).split("\n") : value.split("\n");
 }
-function result(agent, artifact, path14, status, message) {
-  return { agent, kind: artifact.kind, skill: artifact.name, path: path14, status, message };
+function result(agent, artifact, path15, status, message) {
+  return { agent, kind: artifact.kind, skill: artifact.name, path: path15, status, message };
 }
 function summarize(results) {
   return {
@@ -2991,9 +2991,9 @@ async function safeListDefaultSkills(templatesDir) {
     return [];
   }
 }
-async function safeHashFile(path14) {
+async function safeHashFile(path15) {
   try {
-    const content = await readFile8(path14, "utf8");
+    const content = await readFile8(path15, "utf8");
     return `sha256:${createHash3("sha256").update(content).digest("hex")}`;
   } catch {
     return null;
@@ -4513,10 +4513,20 @@ function workspaceCommand() {
 }
 
 // src/cli.ts
-import { pathToFileURL } from "url";
+import { readFileSync, realpathSync } from "fs";
+import path14 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+function readPackageVersion3(moduleUrl = import.meta.url) {
+  const packageJsonPath = path14.join(path14.dirname(fileURLToPath4(moduleUrl)), "..", "package.json");
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  if (typeof packageJson.version !== "string") {
+    throw new Error(`Missing version in ${packageJsonPath}`);
+  }
+  return packageJson.version;
+}
 function createProgram() {
   const program = new Command10();
-  program.name("weave").description("Repo-local LLM wiki and temporary multi-folder AI session tooling.").version("0.1.0");
+  program.name("weave").description("Repo-local LLM wiki and temporary multi-folder AI session tooling.").version(readPackageVersion3());
   program.addCommand(initCommand());
   program.addCommand(addCommand());
   program.addCommand(workspaceCommand());
@@ -4529,10 +4539,22 @@ function createProgram() {
   program.addCommand(taskCommand());
   return program;
 }
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+function isDirectCliInvocation(scriptPath = process.argv[1], moduleUrl = import.meta.url) {
+  if (!scriptPath) {
+    return false;
+  }
+  try {
+    return realpathSync(scriptPath) === realpathSync(fileURLToPath4(moduleUrl));
+  } catch {
+    return false;
+  }
+}
+if (isDirectCliInvocation()) {
   await createProgram().parseAsync(process.argv);
 }
 export {
-  createProgram
+  createProgram,
+  isDirectCliInvocation,
+  readPackageVersion3 as readPackageVersion
 };
 //# sourceMappingURL=cli.js.map