@riotprompt/riotprompt 0.0.20 → 0.0.21

package/dist/{cli.cjs → cli.js}

@@ -1,46 +1,26 @@
 #!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("dotenv/config");
-const commander = require("commander");
-const cardigantime = require("@theunwalked/cardigantime");
-const zod = require("zod");
-const fs$1 = require("fs/promises");
-const path = require("path");
-require("zod-to-json-schema");
-const crypto = require("crypto");
-require("tiktoken");
-const fastXmlParser = require("fast-xml-parser");
-const OpenAI = require("openai");
-const Anthropic = require("@anthropic-ai/sdk");
-const generativeAi = require("@google/generative-ai");
-const fs = require("fs");
-const glob = require("glob");
-function _interopNamespaceDefault(e) {
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
-  if (e) {
-    for (const k in e) {
-      if (k !== "default") {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-const fs__namespace$1 = /* @__PURE__ */ _interopNamespaceDefault(fs$1);
-const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(path);
-const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
-const ConfigSchema = zod.z.object({
-  defaultModel: zod.z.string().default("gpt-4").describe("Default model to use for formatting"),
-  promptsDir: zod.z.string().default(".").describe("Directory containing prompts"),
-  outputDir: zod.z.string().optional().describe("Directory to output formatted prompts")
+import "dotenv/config";
+import { Command } from "commander";
+import { create as create$7 } from "@theunwalked/cardigantime";
+import { z } from "zod";
+import * as path from "path";
+import path__default from "path";
+import "zod-to-json-schema";
+import "tiktoken";
+import { XMLParser } from "fast-xml-parser";
+import OpenAI from "openai";
+import Anthropic from "@anthropic-ai/sdk";
+import { GoogleGenerativeAI } from "@google/generative-ai";
+import { glob } from "glob";
+import * as fs from "fs";
+import crypto from "crypto";
+import * as fs$1 from "fs/promises";
+const ConfigSchema = z.object({
+  defaultModel: z.string().default("gpt-4").describe("Default model to use for formatting"),
+  promptsDir: z.string().default(".").describe("Directory containing prompts"),
+  outputDir: z.string().optional().describe("Directory to output formatted prompts")
 });
-const ParametersSchema = zod.z.record(zod.z.string(), zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean(), zod.z.array(zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean()]))]));
+const ParametersSchema = z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), z.array(z.union([z.string(), z.number(), z.boolean()]))]));
 const apply = (text, parameters) => {
   if (!parameters) {
     return text;
@@ -67,12 +47,12 @@ const apply = (text, parameters) => {
     }
   });
 };
-zod.z.object({
-  text: zod.z.string(),
-  weight: zod.z.number().optional()
+z.object({
+  text: z.string(),
+  weight: z.number().optional()
 });
-const WeightedOptionsSchema = zod.z.object({
-  weight: zod.z.number().optional(),
+const WeightedOptionsSchema = z.object({
+  weight: z.number().optional(),
   parameters: ParametersSchema.optional()
 });
 const create$6 = (text, options = {}) => {
@@ -87,10 +67,10 @@ const create$5 = (text, options = {}) => {
   const weightedOptions = WeightedOptionsSchema.parse(options);
   return create$6(text, weightedOptions);
 };
-const SectionOptionsSchema = zod.z.object({
-  title: zod.z.string().optional(),
-  weight: zod.z.number().optional(),
-  itemWeight: zod.z.number().optional(),
+const SectionOptionsSchema = z.object({
+  title: z.string().optional(),
+  weight: z.number().optional(),
+  itemWeight: z.number().optional(),
   parameters: ParametersSchema.optional().default({})
 });
 const create$4 = (options = {}) => {
@@ -486,18 +466,18 @@ const stringifyJSON = function(obj, visited = /* @__PURE__ */ new Set()) {
   }
   return "";
 };
-const SectionSeparatorSchema = zod.z.enum(["tag", "markdown"]);
-const SectionTitlePropertySchema = zod.z.enum(["title", "name"]);
-const FormatOptionsSchema = zod.z.object({
+const SectionSeparatorSchema = z.enum(["tag", "markdown"]);
+const SectionTitlePropertySchema = z.enum(["title", "name"]);
+const FormatOptionsSchema = z.object({
   sectionSeparator: SectionSeparatorSchema,
-  sectionIndentation: zod.z.boolean(),
+  sectionIndentation: z.boolean(),
   sectionTitleProperty: SectionTitlePropertySchema,
-  sectionTitlePrefix: zod.z.string().optional(),
-  sectionTitleSeparator: zod.z.string().optional(),
-  sectionDepth: zod.z.number().default(0)
+  sectionTitlePrefix: z.string().optional(),
+  sectionTitleSeparator: z.string().optional(),
+  sectionDepth: z.number().default(0)
 });
-const OptionSchema = zod.z.object({
-  logger: zod.z.any().optional().default(DEFAULT_LOGGER),
+const OptionSchema = z.object({
+  logger: z.any().optional().default(DEFAULT_LOGGER),
   formatOptions: FormatOptionsSchema.partial().optional().default(DEFAULT_FORMAT_OPTIONS)
 });
 function isSection(obj) {
@@ -622,22 +602,22 @@ ${formattedItems}`;
     formatArray
   };
 };
-zod.z.object({
-  logger: zod.z.any().optional().default(DEFAULT_LOGGER),
+z.object({
+  logger: z.any().optional().default(DEFAULT_LOGGER),
   parameters: ParametersSchema.optional().default({})
 });
 const create$1 = (params) => {
   const log = params.log || console.log;
   const exists = async (path2) => {
     try {
-      await fs__namespace.promises.stat(path2);
+      await fs.promises.stat(path2);
       return true;
     } catch (error) {
       return false;
     }
   };
   const isDirectory2 = async (path2) => {
-    const stats = await fs__namespace.promises.stat(path2);
+    const stats = await fs.promises.stat(path2);
     if (!stats.isDirectory()) {
       log(`${path2} is not a directory`);
       return false;
@@ -645,7 +625,7 @@ const create$1 = (params) => {
     return true;
   };
   const isFile = async (path2) => {
-    const stats = await fs__namespace.promises.stat(path2);
+    const stats = await fs.promises.stat(path2);
     if (!stats.isFile()) {
       log(`${path2} is not a file`);
       return false;
@@ -654,7 +634,7 @@ const create$1 = (params) => {
   };
   const isReadable = async (path2) => {
     try {
-      await fs__namespace.promises.access(path2, fs__namespace.constants.R_OK);
+      await fs.promises.access(path2, fs.constants.R_OK);
     } catch (error) {
       log(`${path2} is not readable: %s %s`, error.message, error.stack);
       return false;
@@ -663,7 +643,7 @@ const create$1 = (params) => {
   };
   const isWritable = async (path2) => {
     try {
-      await fs__namespace.promises.access(path2, fs__namespace.constants.W_OK);
+      await fs.promises.access(path2, fs.constants.W_OK);
     } catch (error) {
       log(`${path2} is not writable: %s %s`, error.message, error.stack);
       return false;
@@ -681,23 +661,23 @@ const create$1 = (params) => {
   };
   const createDirectory = async (path2) => {
     try {
-      await fs__namespace.promises.mkdir(path2, { recursive: true });
+      await fs.promises.mkdir(path2, { recursive: true });
     } catch (mkdirError) {
       throw new Error(`Failed to create output directory ${path2}: ${mkdirError.message} ${mkdirError.stack}`);
     }
   };
   const readFile = async (path2, encoding) => {
-    return await fs__namespace.promises.readFile(path2, { encoding });
+    return await fs.promises.readFile(path2, { encoding });
   };
   const writeFile = async (path2, data, encoding) => {
-    await fs__namespace.promises.writeFile(path2, data, { encoding });
+    await fs.promises.writeFile(path2, data, { encoding });
   };
   const forEachFileIn = async (directory, callback, options = { pattern: "*.*" }) => {
     try {
       let filesProcessed = 0;
-      const files = await glob.glob(options.pattern, { cwd: directory, nodir: true });
+      const files = await glob(options.pattern, { cwd: directory, nodir: true });
       for (const file of files) {
-        await callback(path.join(directory, file));
+        await callback(path__default.join(directory, file));
         filesProcessed++;
         if (options.limit && filesProcessed >= options.limit) {
           log(`Reached limit of ${options.limit} files, stopping`);
@@ -709,14 +689,14 @@ const create$1 = (params) => {
     }
   };
   const readStream = async (path2) => {
-    return fs__namespace.createReadStream(path2);
+    return fs.createReadStream(path2);
   };
   const hashFile = async (path2, length) => {
     const file = await readFile(path2, "utf8");
     return crypto.createHash("sha256").update(file).digest("hex").slice(0, length);
   };
   const listFiles = async (directory) => {
-    return await fs__namespace.promises.readdir(directory);
+    return await fs.promises.readdir(directory);
   };
   return {
     exists,
@@ -736,9 +716,9 @@ const create$1 = (params) => {
     listFiles
   };
 };
-const OptionsSchema = zod.z.object({
-  logger: zod.z.any().optional().default(DEFAULT_LOGGER),
-  ignorePatterns: zod.z.array(zod.z.string()).optional().default(DEFAULT_IGNORE_PATTERNS),
+const OptionsSchema = z.object({
+  logger: z.any().optional().default(DEFAULT_LOGGER),
+  ignorePatterns: z.array(z.string()).optional().default(DEFAULT_IGNORE_PATTERNS),
   parameters: ParametersSchema.optional().default({})
 });
 function extractFirstHeader(markdownText) {
@@ -783,10 +763,10 @@ const create = (loaderOptions) => {
     const storage = create$1({ log: logger.debug });
     for (const contextDir of contextDirectories) {
       try {
-        const dirName = path.basename(contextDir);
+        const dirName = path__default.basename(contextDir);
         logger.debug(`Processing context directory ${dirName}`);
         let mainContextSection;
-        const contextFile = path.join(contextDir, "context.md");
+        const contextFile = path__default.join(contextDir, "context.md");
         if (await storage.exists(contextFile)) {
           logger.debug(`Found context.md file in ${contextDir}`);
           const mainContextContent = await storage.readFile(contextFile, "utf8");
@@ -811,13 +791,13 @@ const create = (loaderOptions) => {
           }
         });
         const filteredFiles = files.filter((file) => {
-          const fullPath = path.join(contextDir, file);
+          const fullPath = path__default.join(contextDir, file);
           return !ignorePatternsRegex.some((regex) => regex.test(file) || regex.test(fullPath));
         });
         for (const file of filteredFiles) {
           if (file === "context.md") continue;
           logger.debug(`Processing file ${file} in ${contextDir}`);
-          const filePath = path.join(contextDir, file);
+          const filePath = path__default.join(contextDir, file);
           if (await storage.isFile(filePath)) {
             const fileContent = await storage.readFile(filePath, "utf8");
             let sectionName = file;
@@ -845,107 +825,107 @@ const create = (loaderOptions) => {
     load
   };
 };
-zod.z.object({
-  logger: zod.z.any().optional().default(DEFAULT_LOGGER),
-  configDirs: zod.z.array(zod.z.string()).default(["./overrides"]),
-  overrides: zod.z.boolean().default(false),
+z.object({
+  logger: z.any().optional().default(DEFAULT_LOGGER),
+  configDirs: z.array(z.string()).default(["./overrides"]),
+  overrides: z.boolean().default(false),
   parameters: ParametersSchema.optional().default({})
 });
-zod.z.object({
-  logger: zod.z.any().optional().default(DEFAULT_LOGGER),
-  basePath: zod.z.string(),
-  overridePaths: zod.z.array(zod.z.string()).optional().default(["./"]),
-  overrides: zod.z.boolean().optional().default(false),
+z.object({
+  logger: z.any().optional().default(DEFAULT_LOGGER),
+  basePath: z.string(),
+  overridePaths: z.array(z.string()).optional().default(["./"]),
+  overrides: z.boolean().optional().default(false),
   parameters: ParametersSchema.optional().default({})
 });
-zod.z.object({
-  model: zod.z.string(),
-  formatter: zod.z.any().optional(),
-  trackContext: zod.z.boolean().optional().default(true),
-  deduplicateContext: zod.z.boolean().optional().default(true)
+z.object({
+  model: z.string(),
+  formatter: z.any().optional(),
+  trackContext: z.boolean().optional().default(true),
+  deduplicateContext: z.boolean().optional().default(true)
 });
-zod.z.object({
-  name: zod.z.string().min(1),
-  description: zod.z.string().min(1),
-  parameters: zod.z.object({
-    type: zod.z.literal("object"),
-    properties: zod.z.record(zod.z.string(), zod.z.any()).default({}),
+z.object({
+  name: z.string().min(1),
+  description: z.string().min(1),
+  parameters: z.object({
+    type: z.literal("object"),
+    properties: z.record(z.string(), z.any()).default({}),
     // Allow any parameter structure
-    required: zod.z.array(zod.z.string()).optional()
+    required: z.array(z.string()).optional()
   }).passthrough(),
   // Allow additional fields
-  execute: zod.z.custom(
+  execute: z.custom(
     (val) => typeof val === "function",
     { message: "execute must be a function" }
   ),
-  category: zod.z.string().optional(),
-  cost: zod.z.enum(["cheap", "moderate", "expensive"]).optional(),
-  examples: zod.z.array(zod.z.object({
-    scenario: zod.z.string(),
-    params: zod.z.any(),
-    expectedResult: zod.z.string()
+  category: z.string().optional(),
+  cost: z.enum(["cheap", "moderate", "expensive"]).optional(),
+  examples: z.array(z.object({
+    scenario: z.string(),
+    params: z.any(),
+    expectedResult: z.string()
   })).optional()
 }).passthrough();
-const ContentItemSchema = zod.z.union([
-  zod.z.string(),
+const ContentItemSchema = z.union([
+  z.string(),
   // Simple string content
-  zod.z.object({
-    content: zod.z.string(),
-    title: zod.z.string().optional(),
-    weight: zod.z.number().optional()
+  z.object({
+    content: z.string(),
+    title: z.string().optional(),
+    weight: z.number().optional()
   }),
-  zod.z.object({
-    path: zod.z.string(),
-    title: zod.z.string().optional(),
-    weight: zod.z.number().optional()
+  z.object({
+    path: z.string(),
+    title: z.string().optional(),
+    weight: z.number().optional()
   }),
-  zod.z.object({
-    directories: zod.z.array(zod.z.string()),
-    title: zod.z.string().optional(),
-    weight: zod.z.number().optional()
+  z.object({
+    directories: z.array(z.string()),
+    title: z.string().optional(),
+    weight: z.number().optional()
   })
 ]);
-zod.z.object({
+z.object({
   // Core settings
-  basePath: zod.z.string(),
-  logger: zod.z.any().optional().default(DEFAULT_LOGGER),
-  overridePaths: zod.z.array(zod.z.string()).optional().default(["./"]),
-  overrides: zod.z.boolean().optional().default(false),
+  basePath: z.string(),
+  logger: z.any().optional().default(DEFAULT_LOGGER),
+  overridePaths: z.array(z.string()).optional().default(["./"]),
+  overrides: z.boolean().optional().default(false),
   parameters: ParametersSchema.optional().default({}),
   // Content sections
   persona: ContentItemSchema.optional(),
-  instructions: zod.z.array(ContentItemSchema).optional().default([]),
-  content: zod.z.array(ContentItemSchema).optional().default([]),
-  context: zod.z.array(ContentItemSchema).optional().default([]),
+  instructions: z.array(ContentItemSchema).optional().default([]),
+  content: z.array(ContentItemSchema).optional().default([]),
+  context: z.array(ContentItemSchema).optional().default([]),
   // Advanced prompting sections
-  constraints: zod.z.array(ContentItemSchema).optional().default([]),
-  tone: zod.z.array(ContentItemSchema).optional().default([]),
-  examples: zod.z.array(ContentItemSchema).optional().default([]),
-  reasoning: zod.z.array(ContentItemSchema).optional().default([]),
-  responseFormat: zod.z.array(ContentItemSchema).optional().default([]),
-  recap: zod.z.array(ContentItemSchema).optional().default([]),
-  safeguards: zod.z.array(ContentItemSchema).optional().default([]),
-  schema: zod.z.any().optional(),
+  constraints: z.array(ContentItemSchema).optional().default([]),
+  tone: z.array(ContentItemSchema).optional().default([]),
+  examples: z.array(ContentItemSchema).optional().default([]),
+  reasoning: z.array(ContentItemSchema).optional().default([]),
+  responseFormat: z.array(ContentItemSchema).optional().default([]),
+  recap: z.array(ContentItemSchema).optional().default([]),
+  safeguards: z.array(ContentItemSchema).optional().default([]),
+  schema: z.any().optional(),
   // Can be string path, JSON object, or Zod schema
   // Templates and inheritance
-  extends: zod.z.string().optional(),
+  extends: z.string().optional(),
   // Extend another recipe
-  template: zod.z.string().optional(),
+  template: z.string().optional(),
   // Generic template name
   // Tool integration
-  tools: zod.z.any().optional(),
+  tools: z.any().optional(),
   // Tool[] | ToolRegistry
-  toolGuidance: zod.z.union([
-    zod.z.enum(["auto", "minimal", "detailed"]),
-    zod.z.object({
-      strategy: zod.z.enum(["adaptive", "prescriptive", "minimal"]),
-      includeExamples: zod.z.boolean().optional(),
-      explainWhenToUse: zod.z.boolean().optional(),
-      includeCategories: zod.z.boolean().optional(),
-      customInstructions: zod.z.string().optional()
+  toolGuidance: z.union([
+    z.enum(["auto", "minimal", "detailed"]),
+    z.object({
+      strategy: z.enum(["adaptive", "prescriptive", "minimal"]),
+      includeExamples: z.boolean().optional(),
+      explainWhenToUse: z.boolean().optional(),
+      includeCategories: z.boolean().optional(),
+      customInstructions: z.string().optional()
     })
   ]).optional(),
-  toolCategories: zod.z.array(zod.z.string()).optional()
+  toolCategories: z.array(z.string()).optional()
 });
 const toJSON = (prompt) => {
   return JSON.stringify(prompt, null, 2);
@@ -1087,7 +1067,7 @@ const parseNodeToSection = (node) => {
   return section;
 };
 const fromXML = (xmlString) => {
-  const parser = new fastXmlParser.XMLParser({
+  const parser = new XMLParser({
     ignoreAttributes: false,
     attributeNamePrefix: "@_",
     preserveOrder: true,
@@ -1129,18 +1109,18 @@ const fromXML = (xmlString) => {
   });
 };
 const saveToDirectory = async (prompt, basePath) => {
-  await fs__namespace$1.mkdir(basePath, { recursive: true });
+  await fs$1.mkdir(basePath, { recursive: true });
   if (prompt.persona) {
-    await saveSection(prompt.persona, path__namespace.join(basePath, "persona"));
+    await saveSection(prompt.persona, path.join(basePath, "persona"));
   }
   if (prompt.instructions) {
-    await saveSection(prompt.instructions, path__namespace.join(basePath, "instructions"));
+    await saveSection(prompt.instructions, path.join(basePath, "instructions"));
   }
   if (prompt.contexts) {
-    await saveSection(prompt.contexts, path__namespace.join(basePath, "context"));
+    await saveSection(prompt.contexts, path.join(basePath, "context"));
   }
   if (prompt.contents) {
-    await saveSection(prompt.contents, path__namespace.join(basePath, "content"));
+    await saveSection(prompt.contents, path.join(basePath, "content"));
   }
 };
 const saveSection = async (section, targetPath) => {
@@ -1152,20 +1132,20 @@ const saveSection = async (section, targetPath) => {
       if (typeof item === "string") return item;
       return item.text;
     }).join("\n\n");
-    await fs__namespace$1.writeFile(`${targetPath}.md`, content);
+    await fs$1.writeFile(`${targetPath}.md`, content);
     return;
   }
-  await fs__namespace$1.mkdir(targetPath, { recursive: true });
+  await fs$1.mkdir(targetPath, { recursive: true });
   for (let i = 0; i < section.items.length; i++) {
     const item = section.items[i];
     if (typeof item === "object" && "items" in item) {
       const subTitle = item.title || `part-${i + 1}`;
-      const subPath = path__namespace.join(targetPath, subTitle);
+      const subPath = path.join(targetPath, subTitle);
       await saveSection(item, subPath);
     } else {
       const fileName = `item-${i + 1}.md`;
       const content = typeof item === "string" ? item : item.text;
-      await fs__namespace$1.writeFile(path__namespace.join(targetPath, fileName), content);
+      await fs$1.writeFile(path.join(targetPath, fileName), content);
     }
   }
 };
@@ -1258,7 +1238,7 @@ class GeminiProvider {
   async execute(request, options = {}) {
     const apiKey = options.apiKey || process.env.GEMINI_API_KEY;
     if (!apiKey) throw new Error("Gemini API key is required");
-    const genAI = new generativeAi.GoogleGenerativeAI(apiKey);
+    const genAI = new GoogleGenerativeAI(apiKey);
     const modelName = options.model || request.model || "gemini-1.5-pro";
     const generationConfig = {};
     if (request.responseFormat?.type === "json_schema") {
@@ -1364,8 +1344,8 @@ const execute = async (request, options = {}) => {
   const manager = new ExecutionManager();
   return manager.execute(request, options);
 };
-const program = new commander.Command();
-const configManager = cardigantime.create({
+const program = new Command();
+const configManager = create$7({
   configShape: ConfigSchema.shape,
   defaults: {
     configDirectory: process.cwd(),
@@ -1375,7 +1355,7 @@ const configManager = cardigantime.create({
 program.name("riotprompt").description("CLI tool for analyzing and processing prompts").version("0.0.1");
 async function isDirectory(path2) {
   try {
-    const stat = await fs__namespace$1.stat(path2);
+    const stat = await fs$1.stat(path2);
     return stat.isDirectory();
   } catch {
     return false;
@@ -1383,7 +1363,7 @@ async function isDirectory(path2) {
 }
 async function fileExists(path2) {
   try {
-    await fs__namespace$1.access(path2);
+    await fs$1.access(path2);
     return true;
   } catch {
     return false;
@@ -1394,8 +1374,8 @@ async function loadPromptFromDirectory(absolutePromptPath) {
   let instructionsSection;
   let contextSection;
   const loader = create();
-  const personaDir = path__namespace.join(absolutePromptPath, "persona");
-  const personaFile = path__namespace.join(absolutePromptPath, "persona.md");
+  const personaDir = path.join(absolutePromptPath, "persona");
+  const personaFile = path.join(absolutePromptPath, "persona.md");
   if (await isDirectory(personaDir)) {
     console.log("Loading persona from directory...");
     const personaSections = await loader.load([personaDir]);
@@ -1407,14 +1387,14 @@ async function loadPromptFromDirectory(absolutePromptPath) {
     }
   } else if (await fileExists(personaFile)) {
     console.log("Loading persona from file...");
-    const personaContent = await fs__namespace$1.readFile(personaFile, "utf-8");
+    const personaContent = await fs$1.readFile(personaFile, "utf-8");
     personaSection = create$4({ title: "Persona" });
     personaSection.add(create$5(personaContent));
   } else {
     console.log("No persona found, skipping.");
   }
-  const instructionsDir = path__namespace.join(absolutePromptPath, "instructions");
-  const instructionsFile = path__namespace.join(absolutePromptPath, "instructions.md");
+  const instructionsDir = path.join(absolutePromptPath, "instructions");
+  const instructionsFile = path.join(absolutePromptPath, "instructions.md");
   if (await isDirectory(instructionsDir)) {
     console.log("Loading instructions from directory...");
     const instructionSections = await loader.load([instructionsDir]);
@@ -1426,14 +1406,14 @@ async function loadPromptFromDirectory(absolutePromptPath) {
     }
   } else if (await fileExists(instructionsFile)) {
     console.log("Loading instructions from file...");
-    const instructionsContent = await fs__namespace$1.readFile(instructionsFile, "utf-8");
+    const instructionsContent = await fs$1.readFile(instructionsFile, "utf-8");
     instructionsSection = create$4({ title: "Instructions" });
     instructionsSection.add(create$5(instructionsContent));
   }
   if (!instructionsSection) {
     throw new Error("instructions (directory or .md file) is required.");
   }
-  const contextDir = path__namespace.join(absolutePromptPath, "context");
+  const contextDir = path.join(absolutePromptPath, "context");
   if (await isDirectory(contextDir)) {
     console.log("Loading context from directory...");
     const contextSections = await loader.load([contextDir]);
@@ -1454,14 +1434,14 @@ async function loadPromptFromDirectory(absolutePromptPath) {
 }
 async function createAction(promptName, options) {
   try {
-    const basePath = path__namespace.resolve(options.path, promptName);
+    const basePath = path.resolve(options.path, promptName);
     if (await fileExists(basePath)) {
       console.error(`Error: Directory ${basePath} already exists.`);
       process.exit(1);
     }
     if (options.import) {
       console.log(`Importing prompt from ${options.import} to ${basePath}...`);
-      const content = await fs__namespace$1.readFile(options.import, "utf-8");
+      const content = await fs$1.readFile(options.import, "utf-8");
       let prompt;
       if (options.import.endsWith(".json")) {
         prompt = fromJSON(content);
@@ -1474,23 +1454,23 @@ async function createAction(promptName, options) {
       console.log(`Successfully imported to ${basePath}`);
     } else {
       console.log(`Creating prompt structure at ${basePath}...`);
-      await fs__namespace$1.mkdir(basePath, { recursive: true });
+      await fs$1.mkdir(basePath, { recursive: true });
       const personaText = options.persona || "You are a helpful AI assistant.";
-      await fs__namespace$1.writeFile(path__namespace.join(basePath, "persona.md"), personaText);
+      await fs$1.writeFile(path.join(basePath, "persona.md"), personaText);
       console.log("Created persona.md");
       const instructionsText = options.instructions || "Please analyze the following request.";
-      await fs__namespace$1.writeFile(path__namespace.join(basePath, "instructions.md"), instructionsText);
+      await fs$1.writeFile(path.join(basePath, "instructions.md"), instructionsText);
       console.log("Created instructions.md");
       if (options.context) {
-        const contextDir = path__namespace.join(basePath, "context");
-        await fs__namespace$1.mkdir(contextDir);
-        await fs__namespace$1.writeFile(path__namespace.join(contextDir, "README.md"), "Place context files (json, md, txt) in this directory.");
+        const contextDir = path.join(basePath, "context");
+        await fs$1.mkdir(contextDir);
+        await fs$1.writeFile(path.join(contextDir, "README.md"), "Place context files (json, md, txt) in this directory.");
         console.log("Created context directory");
       }
       console.log(`
 Prompt '${promptName}' created successfully!`);
     }
-    console.log(`Run 'riotprompt process ${path__namespace.join(options.path, promptName)}' to test it.`);
+    console.log(`Run 'riotprompt process ${path.join(options.path, promptName)}' to test it.`);
   } catch (error) {
     console.error("Error creating prompt:", error);
     process.exit(1);
@@ -1502,7 +1482,7 @@ async function processAction(promptPath, options) {
     const modelName = options.model || config.defaultModel;
     console.log(`Processing prompt from: ${promptPath}`);
     console.log(`Using model: ${modelName}`);
-    const absolutePromptPath = path__namespace.resolve(promptPath);
+    const absolutePromptPath = path.resolve(promptPath);
     if (!await fileExists(absolutePromptPath)) {
       console.error(`Error: Prompt path not found at ${absolutePromptPath}`);
       process.exit(1);
@@ -1511,7 +1491,7 @@ async function processAction(promptPath, options) {
     if (await isDirectory(absolutePromptPath)) {
       prompt = await loadPromptFromDirectory(absolutePromptPath);
     } else {
-      const content = await fs__namespace$1.readFile(absolutePromptPath, "utf-8");
+      const content = await fs$1.readFile(absolutePromptPath, "utf-8");
       if (absolutePromptPath.endsWith(".json")) {
         prompt = fromJSON(content);
       } else if (absolutePromptPath.endsWith(".xml")) {
@@ -1538,7 +1518,7 @@ ${m.content}`).join("\n\n");
       }
     }
     if (options.output) {
-      await fs__namespace$1.writeFile(options.output, output);
+      await fs$1.writeFile(options.output, output);
       console.log(`Output written to ${options.output}`);
     } else {
       console.log("\n--- Result ---\n");
@@ -1555,7 +1535,7 @@ async function executeAction(promptPath, options) {
     const modelName = options.model || config.defaultModel;
     console.log(`Executing prompt from: ${promptPath}`);
     console.log(`Using model: ${modelName}`);
-    const absolutePromptPath = path__namespace.resolve(promptPath);
+    const absolutePromptPath = path.resolve(promptPath);
     if (!await fileExists(absolutePromptPath)) {
       console.error(`Error: Prompt path not found at ${absolutePromptPath}`);
       process.exit(1);
@@ -1564,7 +1544,7 @@ async function executeAction(promptPath, options) {
     if (await isDirectory(absolutePromptPath)) {
       prompt = await loadPromptFromDirectory(absolutePromptPath);
     } else {
-      const content = await fs__namespace$1.readFile(absolutePromptPath, "utf-8");
+      const content = await fs$1.readFile(absolutePromptPath, "utf-8");
       if (absolutePromptPath.endsWith(".json")) {
         prompt = fromJSON(content);
       } else if (absolutePromptPath.endsWith(".xml")) {
@@ -1602,16 +1582,19 @@ async function main() {
   program.command("execute <promptPath>").description("Execute a prompt using an LLM provider").option("-m, --model <model>", "Model to use (e.g., gpt-4, claude-3-opus, gemini-1.5-pro)").option("-k, --key <key>", "API Key (overrides env vars)").option("-t, --temperature <number>", "Temperature (0-1)", parseFloat).option("--max-tokens <number>", "Max tokens", parseInt).action(executeAction);
   await program.parseAsync();
 }
-if (typeof require !== "undefined" && require.main === module) {
+const isRunningAsCLI = process.argv[1] && (process.argv[1].endsWith("cli.js") || process.argv[1].endsWith("cli.ts")) && !process.argv[1].includes("vitest") && !process.argv[1].includes("node_modules");
+if (isRunningAsCLI) {
   main().catch((err) => {
     console.error(err);
     process.exit(1);
   });
 }
-exports.createAction = createAction;
-exports.executeAction = executeAction;
-exports.fileExists = fileExists;
-exports.isDirectory = isDirectory;
-exports.loadPromptFromDirectory = loadPromptFromDirectory;
-exports.main = main;
-exports.processAction = processAction;
+export {
+  createAction,
+  executeAction,
+  fileExists,
+  isDirectory,
+  loadPromptFromDirectory,
+  main,
+  processAction
+};