@mastra/code-sdk 0.0.0-esbuild-bundle-worker-20260807173433

package/dist/utils/slash-command-loader.js

@@ -0,0 +1,141 @@
+import { DEFAULT_CONFIG_DIR } from "../constants.js";
+import { isPathWithinRoot } from "./path-security.js";
+import { promises } from "fs";
+import * as path$1 from "path";
+import { parse } from "yaml";
+//#region src/utils/slash-command-loader.ts
+/**
+* Parse a command file and extract metadata and template
+* Supports both frontmatter-based and plain markdown files
+*/
+async function parseCommandFile(filePath, baseDir) {
+	try {
+		const content = await promises.readFile(filePath, "utf-8");
+		if (!content.trim().startsWith("---")) return {
+			name: baseDir ? extractCommandName(filePath, baseDir) : path$1.basename(filePath, ".md"),
+			description: "",
+			template: content,
+			sourcePath: filePath
+		};
+		const parts = content.split("---");
+		if (parts.length < 3) return null;
+		const frontmatter = parts[1].trim();
+		const template = parts.slice(2).join("---").trim();
+		const metadata = parse(frontmatter);
+		let name;
+		if (typeof metadata?.name === "string" && metadata.name) name = metadata.name;
+		else if (baseDir) name = extractCommandName(filePath, baseDir);
+		else name = path$1.basename(filePath, ".md");
+		return {
+			name,
+			description: typeof metadata?.description === "string" ? metadata.description : "",
+			template,
+			sourcePath: filePath,
+			namespace: typeof metadata?.namespace === "string" ? metadata.namespace : void 0,
+			goal: metadata?.goal === true
+		};
+	} catch (error) {
+		console.error(`Error parsing command file ${filePath}:`, error);
+		return null;
+	}
+}
+/**
+* Extract command name from file path
+* Converts path like "git/commit.md" to "git:commit"
+*/
+function extractCommandName(filePath, baseDir) {
+	const relativePath = path$1.relative(baseDir, filePath);
+	const dirName = path$1.dirname(relativePath);
+	const baseName = path$1.basename(relativePath, ".md");
+	if (dirName === "." || dirName === "") return baseName;
+	return `${dirName.replace(/[\\/]/g, ":")}:${baseName}`;
+}
+async function scanCommandDirectory(dirPath, rootDir, options = {}) {
+	const baseDir = rootDir ?? dirPath;
+	const commands = [];
+	const visitedDirectories = options.visitedDirectories ?? /* @__PURE__ */ new Set();
+	try {
+		const realDirectory = await promises.realpath(dirPath);
+		const realAllowedRoot = options.allowedRoot ? await promises.realpath(options.allowedRoot) : void 0;
+		if (realAllowedRoot && !isPathWithinRoot(realDirectory, realAllowedRoot)) return commands;
+		if (visitedDirectories.has(realDirectory)) return commands;
+		visitedDirectories.add(realDirectory);
+		const entries = await promises.readdir(dirPath, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = path$1.join(dirPath, entry.name);
+			const stats = entry.isSymbolicLink() ? await promises.stat(fullPath).catch(() => null) : entry;
+			if (!stats) continue;
+			if (stats.isDirectory()) {
+				const subCommands = await scanCommandDirectory(fullPath, baseDir, {
+					...options,
+					visitedDirectories
+				});
+				commands.push(...subCommands);
+			} else if (entry.name.endsWith(".md") && stats.isFile()) {
+				if (realAllowedRoot) {
+					const realFile = await promises.realpath(fullPath).catch(() => null);
+					if (!realFile || !isPathWithinRoot(realFile, realAllowedRoot)) continue;
+				}
+				const command = await parseCommandFile(fullPath, baseDir);
+				if (command) commands.push(command);
+			}
+		}
+	} catch {}
+	return commands;
+}
+/**
+* Load custom slash commands from all configured directories
+* Priority: mastra project > claude project > opencode project > mastra user > claude user > opencode user
+*/
+async function loadCustomCommands(projectDir, configDirName = DEFAULT_CONFIG_DIR, extraCommandDirs = []) {
+	const commandMap = /* @__PURE__ */ new Map();
+	const addCommands = (newCommands) => {
+		for (const cmd of newCommands) commandMap.set(cmd.name, cmd);
+	};
+	const homeDir = process.env.HOME || process.env.USERPROFILE;
+	if (homeDir) addCommands(await scanCommandDirectory(path$1.join(homeDir, ".opencode", "command")));
+	if (homeDir) addCommands(await scanCommandDirectory(path$1.join(homeDir, ".claude", "commands")));
+	if (homeDir) addCommands(await scanCommandDirectory(path$1.join(homeDir, configDirName, "commands")));
+	if (projectDir) addCommands(await scanCommandDirectory(path$1.join(projectDir, ".opencode", "command"), void 0, { allowedRoot: projectDir }));
+	if (projectDir) addCommands(await scanCommandDirectory(path$1.join(projectDir, ".claude", "commands"), void 0, { allowedRoot: projectDir }));
+	if (projectDir) addCommands(await scanCommandDirectory(path$1.join(projectDir, configDirName, "commands"), void 0, { allowedRoot: projectDir }));
+	for (const commandsDir of extraCommandDirs) addCommands(await scanCommandDirectory(commandsDir, void 0, { allowedRoot: commandsDir }));
+	return Array.from(commandMap.values());
+}
+/**
+* Get the commands directory path for a project
+*/
+function getProjectCommandsDir(projectDir, configDirName = DEFAULT_CONFIG_DIR) {
+	return path$1.join(projectDir, configDirName, "commands");
+}
+/**
+* Initialize a commands directory with an example command
+*/
+async function initCommandsDirectory(projectDir, configDirName = DEFAULT_CONFIG_DIR) {
+	const commandsDir = getProjectCommandsDir(projectDir, configDirName);
+	try {
+		await promises.mkdir(commandsDir, { recursive: true });
+		const examplePath = path$1.join(commandsDir, "example.md");
+		const exampleContent = `---
+name: example
+description: An example slash command
+---
+
+This is an example slash command template.
+You can use variables like \$ARGUMENTS or \$1, \$2 for positional args.
+You can also include file content with @filename.
+Shell commands with !command will be executed and output included.
+`;
+		try {
+			await promises.access(examplePath);
+		} catch {
+			await promises.writeFile(examplePath, exampleContent, "utf-8");
+		}
+	} catch (error) {
+		console.error("Error initializing commands directory:", error);
+	}
+}
+//#endregion
+export { extractCommandName, getProjectCommandsDir, initCommandsDirectory, loadCustomCommands, parseCommandFile, scanCommandDirectory };
+
+//# sourceMappingURL=slash-command-loader.js.map

package/dist/utils/slash-command-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slash-command-loader.js","names":["fs","path","parseYaml"],"sources":["../../src/utils/slash-command-loader.ts"],"sourcesContent":["import { promises as fs } from 'node:fs';\nimport * as path from 'node:path';\nimport { parse as parseYaml } from 'yaml';\nimport { DEFAULT_CONFIG_DIR } from '../constants.js';\nimport { isPathWithinRoot } from './path-security.js';\n\n/**\n * Metadata for a slash command\n */\nexport interface SlashCommandMetadata {\n  /** Command name (e.g., \"git:commit\") */\n  name: string;\n  /** Human-readable description */\n  description: string;\n  /** The command template with variables */\n  template: string;\n  /** Source file path */\n  sourcePath: string;\n  /** Namespace derived from directory structure */\n  namespace?: string;\n  /** Whether this command should also be exposed as /goal/<name> */\n  goal?: boolean;\n}\n\n/**\n * Parse a command file and extract metadata and template\n * Supports both frontmatter-based and plain markdown files\n */\nexport async function parseCommandFile(filePath: string, baseDir?: string): Promise<SlashCommandMetadata | null> {\n  try {\n    const content = await fs.readFile(filePath, 'utf-8');\n    const trimmedContent = content.trim();\n\n    // Check if file has frontmatter (starts with ---)\n    if (!trimmedContent.startsWith('---')) {\n      // No frontmatter - treat entire file as template\n      // Derive name from file path\n      const name = baseDir ? extractCommandName(filePath, baseDir) : path.basename(filePath, '.md');\n\n      return {\n        name,\n        description: '',\n        template: content,\n        sourcePath: filePath,\n      };\n    }\n\n    // Split frontmatter and template\n    const parts = content.split('---');\n    if (parts.length < 3) {\n      return null;\n    }\n\n    const frontmatter = parts[1]!.trim();\n    const template = parts.slice(2).join('---').trim();\n\n    // Parse YAML frontmatter\n    const metadata = parseYaml(frontmatter) as Record<string, unknown>;\n\n    // Derive name from file path if not specified in frontmatter\n    let name: string;\n    if (typeof metadata?.name === 'string' && metadata.name) {\n      name = metadata.name;\n    } else if (baseDir) {\n      name = extractCommandName(filePath, baseDir);\n    } else {\n      name = path.basename(filePath, '.md');\n    }\n\n    return {\n      name,\n      description: typeof metadata?.description === 'string' ? metadata.description : '',\n      template,\n      sourcePath: filePath,\n      namespace: typeof metadata?.namespace === 'string' ? metadata.namespace : undefined,\n      goal: metadata?.goal === true,\n    };\n  } catch (error) {\n    console.error(`Error parsing command file ${filePath}:`, error);\n    return null;\n  }\n}\n\n/**\n * Extract command name from file path\n * Converts path like \"git/commit.md\" to \"git:commit\"\n */\nexport function extractCommandName(filePath: string, baseDir: string): string {\n  const relativePath = path.relative(baseDir, filePath);\n  const dirName = path.dirname(relativePath);\n  const baseName = path.basename(relativePath, '.md');\n\n  if (dirName === '.' || dirName === '') {\n    return baseName;\n  }\n\n  // Replace path separators with colons for namespacing\n  const namespace = dirName.replace(/[\\\\/]/g, ':');\n  return `${namespace}:${baseName}`;\n}\n\n/**\n * Recursively scan a directory for command files.\n * @param dirPath - Current directory to scan\n * @param rootDir - Original root commands directory (used for namespace derivation).\n *                  When omitted the first call sets it to dirPath.\n */\nexport interface ScanCommandDirectoryOptions {\n  allowedRoot?: string;\n  visitedDirectories?: Set<string>;\n}\n\nexport async function scanCommandDirectory(\n  dirPath: string,\n  rootDir?: string,\n  options: ScanCommandDirectoryOptions = {},\n): Promise<SlashCommandMetadata[]> {\n  const baseDir = rootDir ?? dirPath;\n  const commands: SlashCommandMetadata[] = [];\n  const visitedDirectories = options.visitedDirectories ?? new Set<string>();\n\n  try {\n    const realDirectory = await fs.realpath(dirPath);\n    const realAllowedRoot = options.allowedRoot ? await fs.realpath(options.allowedRoot) : undefined;\n    if (realAllowedRoot && !isPathWithinRoot(realDirectory, realAllowedRoot)) return commands;\n    if (visitedDirectories.has(realDirectory)) return commands;\n    visitedDirectories.add(realDirectory);\n\n    const entries = await fs.readdir(dirPath, { withFileTypes: true });\n\n    for (const entry of entries) {\n      const fullPath = path.join(dirPath, entry.name);\n      const stats = entry.isSymbolicLink() ? await fs.stat(fullPath).catch(() => null) : entry;\n      if (!stats) continue;\n\n      if (stats.isDirectory()) {\n        // Recursively scan subdirectories, preserving the root directory for namespace derivation\n        const subCommands = await scanCommandDirectory(fullPath, baseDir, {\n          ...options,\n          visitedDirectories,\n        });\n        commands.push(...subCommands);\n      } else if (entry.name.endsWith('.md') && stats.isFile()) {\n        if (realAllowedRoot) {\n          const realFile = await fs.realpath(fullPath).catch(() => null);\n          if (!realFile || !isPathWithinRoot(realFile, realAllowedRoot)) continue;\n        }\n\n        // Parse markdown command files, passing the root commands dir as baseDir for name derivation\n        const command = await parseCommandFile(fullPath, baseDir);\n        if (command) {\n          commands.push(command);\n        }\n      }\n    }\n  } catch {\n    // Directory doesn't exist or can't be read - silently skip\n  }\n\n  return commands;\n}\n/**\n * Load custom slash commands from all configured directories\n * Priority: mastra project > claude project > opencode project > mastra user > claude user > opencode user\n */\nexport async function loadCustomCommands(\n  projectDir?: string,\n  configDirName = DEFAULT_CONFIG_DIR,\n  extraCommandDirs: string[] = [],\n): Promise<SlashCommandMetadata[]> {\n  // Use a Map so later (higher priority) sources override earlier ones with the same name\n  const commandMap = new Map<string, SlashCommandMetadata>();\n\n  const addCommands = (newCommands: SlashCommandMetadata[]) => {\n    for (const cmd of newCommands) {\n      commandMap.set(cmd.name, cmd);\n    }\n  };\n\n  const homeDir = process.env.HOME || process.env.USERPROFILE;\n\n  // 1. Load from opencode user directory ~/.opencode/command (lowest priority)\n  if (homeDir) {\n    const opencodeUserDir = path.join(homeDir, '.opencode', 'command');\n    const opencodeUserCommands = await scanCommandDirectory(opencodeUserDir);\n    addCommands(opencodeUserCommands);\n  }\n\n  // 2. Load from claude user directory ~/.claude/commands (Claude Code compat)\n  if (homeDir) {\n    const claudeUserDir = path.join(homeDir, '.claude', 'commands');\n    const claudeUserCommands = await scanCommandDirectory(claudeUserDir);\n    addCommands(claudeUserCommands);\n  }\n\n  // 3. Load from mastra user directory ~/<configDirName>/commands\n  if (homeDir) {\n    const mastraUserDir = path.join(homeDir, configDirName, 'commands');\n    const mastraUserCommands = await scanCommandDirectory(mastraUserDir);\n    addCommands(mastraUserCommands);\n  }\n\n  // 4. Load from opencode project directory .opencode/command\n  if (projectDir) {\n    const opencodeProjectDir = path.join(projectDir, '.opencode', 'command');\n    const opencodeProjectCommands = await scanCommandDirectory(opencodeProjectDir, undefined, {\n      allowedRoot: projectDir,\n    });\n    addCommands(opencodeProjectCommands);\n  }\n\n  // 5. Load from claude project directory .claude/commands (Claude Code compat)\n  if (projectDir) {\n    const claudeProjectDir = path.join(projectDir, '.claude', 'commands');\n    const claudeProjectCommands = await scanCommandDirectory(claudeProjectDir, undefined, {\n      allowedRoot: projectDir,\n    });\n    addCommands(claudeProjectCommands);\n  }\n\n  // 6. Load from mastra project directory <configDirName>/commands\n  if (projectDir) {\n    const mastraProjectDir = path.join(projectDir, configDirName, 'commands');\n    const mastraProjectCommands = await scanCommandDirectory(mastraProjectDir, undefined, {\n      allowedRoot: projectDir,\n    });\n    addCommands(mastraProjectCommands);\n  }\n\n  // 7. Load from active plugin command directories (highest priority)\n  for (const commandsDir of extraCommandDirs) {\n    addCommands(await scanCommandDirectory(commandsDir, undefined, { allowedRoot: commandsDir }));\n  }\n\n  return Array.from(commandMap.values());\n}\n\n/**\n * Get the commands directory path for a project\n */\nexport function getProjectCommandsDir(projectDir: string, configDirName = DEFAULT_CONFIG_DIR): string {\n  return path.join(projectDir, configDirName, 'commands');\n}\n\n/**\n * Initialize a commands directory with an example command\n */\nexport async function initCommandsDirectory(projectDir: string, configDirName = DEFAULT_CONFIG_DIR): Promise<void> {\n  const commandsDir = getProjectCommandsDir(projectDir, configDirName);\n\n  try {\n    await fs.mkdir(commandsDir, { recursive: true });\n\n    // Create an example command\n    const examplePath = path.join(commandsDir, 'example.md');\n    const exampleContent = `---\nname: example\ndescription: An example slash command\n---\n\nThis is an example slash command template.\nYou can use variables like \\$ARGUMENTS or \\$1, \\$2 for positional args.\nYou can also include file content with @filename.\nShell commands with !command will be executed and output included.\n`;\n\n    try {\n      await fs.access(examplePath);\n      // File already exists, don't overwrite\n    } catch {\n      await fs.writeFile(examplePath, exampleContent, 'utf-8');\n    }\n  } catch (error) {\n    console.error('Error initializing commands directory:', error);\n  }\n}\n"],"mappings":"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"}

package/dist/utils/slash-command-processor.d.ts

@@ -0,0 +1,14 @@
+import type { SlashCommandMetadata } from './slash-command-loader.js';
+/**
+ * Process a slash command by replacing variables and executing shell commands
+ */
+export declare function processSlashCommand(command: SlashCommandMetadata, args: string[], workingDir: string): Promise<string>;
+/**
+ * Format a command for display in help/autocomplete
+ */
+export declare function formatCommandForDisplay(command: SlashCommandMetadata): string;
+/**
+ * Group commands by namespace for display
+ */
+export declare function groupCommandsByNamespace(commands: SlashCommandMetadata[]): Map<string, SlashCommandMetadata[]>;
+//# sourceMappingURL=slash-command-processor.d.ts.map

package/dist/utils/slash-command-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slash-command-processor.d.ts","sourceRoot":"","sources":["../../src/utils/slash-command-processor.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEtE;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,oBAAoB,EAC7B,IAAI,EAAE,MAAM,EAAE,EACd,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC,CAgBjB;AA0FD;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,oBAAoB,GAAG,MAAM,CAQ7E;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,oBAAoB,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,oBAAoB,EAAE,CAAC,CAc9G"}

package/dist/utils/slash-command-processor.js

@@ -0,0 +1,105 @@
+import { promises } from "fs";
+import * as path$1 from "path";
+import { execSync } from "child_process";
+//#region src/utils/slash-command-processor.ts
+/**
+* Process a slash command by replacing variables and executing shell commands
+*/
+async function processSlashCommand(command, args, workingDir) {
+	const { result: withArgs, shouldAppendRawArgs } = replaceArguments(command.template, args);
+	let result = withArgs;
+	result = await replaceShellOutput(result, workingDir);
+	result = await replaceFileReferences(result, workingDir);
+	if (shouldAppendRawArgs) result = result.trimEnd() + `\n\nARGUMENTS: ${args.join(" ")}`;
+	return result;
+}
+/**
+* Replace argument variables in template
+* $ARGUMENTS - all arguments joined
+* $1, $2, etc. - positional arguments
+*/
+function replaceArguments(template, args) {
+	let result = template;
+	const hasArgumentsVar = /\$ARGUMENTS/.test(template);
+	const hasPositionalVar = /\$[1-9]\d*/.test(template);
+	result = result.replace(/\$ARGUMENTS/g, args.join(" "));
+	args.forEach((_, index) => {
+		const argNumber = index + 1;
+		const pattern = new RegExp(`\\\$${argNumber}\\+`, "g");
+		result = result.replace(pattern, args.slice(index).join(" "));
+	});
+	args.forEach((arg, index) => {
+		const pattern = new RegExp(`\\\$${index + 1}`, "g");
+		result = result.replace(pattern, arg);
+	});
+	result = result.replace(/\$[1-9]\d*\+?/g, "");
+	return {
+		result,
+		shouldAppendRawArgs: !hasArgumentsVar && !hasPositionalVar && args.length > 0
+	};
+}
+/**
+* Replace shell command references with their output
+* Format: !`command`
+*/
+async function replaceShellOutput(template, workingDir) {
+	const matches = [...template.matchAll(/!`([^`]+)`/g)];
+	let result = template;
+	for (const match of matches) {
+		const [fullMatch, command] = match;
+		try {
+			const output = execSync(command, {
+				cwd: workingDir,
+				encoding: "utf-8",
+				timeout: 3e4,
+				maxBuffer: 1024 * 1024
+			});
+			result = result.replace(fullMatch, output.trim());
+		} catch (error) {
+			console.error(`Error executing shell command "${command}":`, error);
+			result = result.replace(fullMatch, `[Error: Failed to execute "${command}"]`);
+		}
+	}
+	return result;
+}
+/**
+* Replace file references with file content
+* Format: @filename or @path/to/file
+*/
+async function replaceFileReferences(template, workingDir) {
+	const matches = [...template.matchAll(/@([\w./-]+)/g)];
+	let result = template;
+	for (const match of matches) {
+		const [fullMatch, filePath] = match;
+		try {
+			const fullPath = path$1.resolve(workingDir, filePath);
+			const content = await promises.readFile(fullPath, "utf-8");
+			result = result.replace(fullMatch, content);
+		} catch {}
+	}
+	return result;
+}
+/**
+* Format a command for display in help/autocomplete
+*/
+function formatCommandForDisplay(command) {
+	const parts = [command.name];
+	if (command.description) parts.push(`- ${command.description}`);
+	return parts.join(" ");
+}
+/**
+* Group commands by namespace for display
+*/
+function groupCommandsByNamespace(commands) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const command of commands) {
+		const namespace = command.namespace || command.name.split(":")[0] || "general";
+		if (!groups.has(namespace)) groups.set(namespace, []);
+		groups.get(namespace).push(command);
+	}
+	return groups;
+}
+//#endregion
+export { formatCommandForDisplay, groupCommandsByNamespace, processSlashCommand };
+
+//# sourceMappingURL=slash-command-processor.js.map

package/dist/utils/slash-command-processor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slash-command-processor.js","names":["path","fs"],"sources":["../../src/utils/slash-command-processor.ts"],"sourcesContent":["import { execSync } from 'node:child_process';\nimport { promises as fs } from 'node:fs';\nimport * as path from 'node:path';\nimport type { SlashCommandMetadata } from './slash-command-loader.js';\n\n/**\n * Process a slash command by replacing variables and executing shell commands\n */\nexport async function processSlashCommand(\n  command: SlashCommandMetadata,\n  args: string[],\n  workingDir: string,\n): Promise<string> {\n  const { result: withArgs, shouldAppendRawArgs } = replaceArguments(command.template, args);\n  let result = withArgs;\n\n  // Replace shell commands\n  result = await replaceShellOutput(result, workingDir);\n\n  // Replace file references\n  result = await replaceFileReferences(result, workingDir);\n\n  // Append raw args after shell/file processing to avoid executing user input\n  if (shouldAppendRawArgs) {\n    result = result.trimEnd() + `\\n\\nARGUMENTS: ${args.join(' ')}`;\n  }\n\n  return result;\n}\n\n/**\n * Replace argument variables in template\n * $ARGUMENTS - all arguments joined\n * $1, $2, etc. - positional arguments\n */\nfunction replaceArguments(template: string, args: string[]): { result: string; shouldAppendRawArgs: boolean } {\n  let result = template;\n\n  // Check if template references any argument variables\n  const hasArgumentsVar = /\\$ARGUMENTS/.test(template);\n  const hasPositionalVar = /\\$[1-9]\\d*/.test(template);\n\n  // Replace $ARGUMENTS with all args joined\n  result = result.replace(/\\$ARGUMENTS/g, args.join(' '));\n\n  // Replace range arguments $1+, $2+, etc. before single positional arguments.\n  args.forEach((_, index) => {\n    const argNumber = index + 1;\n    const pattern = new RegExp(`\\\\\\$${argNumber}\\\\+`, 'g');\n    result = result.replace(pattern, args.slice(index).join(' '));\n  });\n\n  // Replace positional arguments $1, $2, etc.\n  args.forEach((arg, index) => {\n    const pattern = new RegExp(`\\\\\\$${index + 1}`, 'g');\n    result = result.replace(pattern, arg);\n  });\n\n  // Clear unused positional and range arguments\n  result = result.replace(/\\$[1-9]\\d*\\+?/g, '');\n\n  return {\n    result,\n    shouldAppendRawArgs: !hasArgumentsVar && !hasPositionalVar && args.length > 0,\n  };\n}\n\n/**\n * Replace shell command references with their output\n * Format: !`command`\n */\nasync function replaceShellOutput(template: string, workingDir: string): Promise<string> {\n  const shellPattern = /!`([^`]+)`/g;\n  const matches = [...template.matchAll(shellPattern)];\n\n  let result = template;\n  for (const match of matches) {\n    const [fullMatch, command] = match;\n    try {\n      const output = execSync(command!, {\n        cwd: workingDir,\n        encoding: 'utf-8',\n        timeout: 30000,\n        maxBuffer: 1024 * 1024, // 1MB buffer\n      });\n      result = result.replace(fullMatch, output.trim());\n    } catch (error) {\n      console.error(`Error executing shell command \"${command}\":`, error);\n      result = result.replace(fullMatch, `[Error: Failed to execute \"${command}\"]`);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Replace file references with file content\n * Format: @filename or @path/to/file\n */\nasync function replaceFileReferences(template: string, workingDir: string): Promise<string> {\n  const filePattern = /@([\\w./-]+)/g;\n  const matches = [...template.matchAll(filePattern)];\n\n  let result = template;\n  for (const match of matches) {\n    const [fullMatch, filePath] = match;\n    try {\n      const fullPath = path.resolve(workingDir, filePath!);\n      const content = await fs.readFile(fullPath, 'utf-8');\n      result = result.replace(fullMatch, content);\n    } catch {\n      // Leave literal @mentions/search qualifiers such as @me intact when they do not resolve to files.\n    }\n  }\n\n  return result;\n}\n\n/**\n * Format a command for display in help/autocomplete\n */\nexport function formatCommandForDisplay(command: SlashCommandMetadata): string {\n  const parts = [command.name];\n\n  if (command.description) {\n    parts.push(`- ${command.description}`);\n  }\n\n  return parts.join(' ');\n}\n\n/**\n * Group commands by namespace for display\n */\nexport function groupCommandsByNamespace(commands: SlashCommandMetadata[]): Map<string, SlashCommandMetadata[]> {\n  const groups = new Map<string, SlashCommandMetadata[]>();\n\n  for (const command of commands) {\n    const namespace = command.namespace || command.name.split(':')[0] || 'general';\n\n    if (!groups.has(namespace)) {\n      groups.set(namespace, []);\n    }\n\n    groups.get(namespace)!.push(command);\n  }\n\n  return groups;\n}\n"],"mappings":";;;;;;;AAQA,eAAsB,oBACpB,SACA,MACA,YACiB;CACjB,MAAM,EAAE,QAAQ,UAAU,wBAAwB,iBAAiB,QAAQ,UAAU,IAAI;CACzF,IAAI,SAAS;CAGb,SAAS,MAAM,mBAAmB,QAAQ,UAAU;CAGpD,SAAS,MAAM,sBAAsB,QAAQ,UAAU;CAGvD,IAAI,qBACF,SAAS,OAAO,QAAQ,IAAI,kBAAkB,KAAK,KAAK,GAAG;CAG7D,OAAO;AACT;;;;;;AAOA,SAAS,iBAAiB,UAAkB,MAAkE;CAC5G,IAAI,SAAS;CAGb,MAAM,kBAAkB,cAAc,KAAK,QAAQ;CACnD,MAAM,mBAAmB,aAAa,KAAK,QAAQ;CAGnD,SAAS,OAAO,QAAQ,gBAAgB,KAAK,KAAK,GAAG,CAAC;CAGtD,KAAK,SAAS,GAAG,UAAU;EACzB,MAAM,YAAY,QAAQ;EAC1B,MAAM,UAAU,IAAI,OAAO,OAAO,UAAU,MAAM,GAAG;EACrD,SAAS,OAAO,QAAQ,SAAS,KAAK,MAAM,KAAK,CAAC,CAAC,KAAK,GAAG,CAAC;CAC9D,CAAC;CAGD,KAAK,SAAS,KAAK,UAAU;EAC3B,MAAM,UAAU,IAAI,OAAO,OAAO,QAAQ,KAAK,GAAG;EAClD,SAAS,OAAO,QAAQ,SAAS,GAAG;CACtC,CAAC;CAGD,SAAS,OAAO,QAAQ,kBAAkB,EAAE;CAE5C,OAAO;EACL;EACA,qBAAqB,CAAC,mBAAmB,CAAC,oBAAoB,KAAK,SAAS;CAC9E;AACF;;;;;AAMA,eAAe,mBAAmB,UAAkB,YAAqC;CAEvF,MAAM,UAAU,CAAC,GAAG,SAAS,SAAS,aAAY,CAAC;CAEnD,IAAI,SAAS;CACb,KAAK,MAAM,SAAS,SAAS;EAC3B,MAAM,CAAC,WAAW,WAAW;EAC7B,IAAI;GACF,MAAM,SAAS,SAAS,SAAU;IAChC,KAAK;IACL,UAAU;IACV,SAAS;IACT,WAAW,OAAO;GACpB,CAAC;GACD,SAAS,OAAO,QAAQ,WAAW,OAAO,KAAK,CAAC;EAClD,SAAS,OAAO;GACd,QAAQ,MAAM,kCAAkC,QAAQ,KAAK,KAAK;GAClE,SAAS,OAAO,QAAQ,WAAW,8BAA8B,QAAQ,GAAG;EAC9E;CACF;CAEA,OAAO;AACT;;;;;AAMA,eAAe,sBAAsB,UAAkB,YAAqC;CAE1F,MAAM,UAAU,CAAC,GAAG,SAAS,SAAS,cAAW,CAAC;CAElD,IAAI,SAAS;CACb,KAAK,MAAM,SAAS,SAAS;EAC3B,MAAM,CAAC,WAAW,YAAY;EAC9B,IAAI;GACF,MAAM,WAAWA,OAAK,QAAQ,YAAY,QAAS;GACnD,MAAM,UAAU,MAAMC,SAAG,SAAS,UAAU,OAAO;GACnD,SAAS,OAAO,QAAQ,WAAW,OAAO;EAC5C,QAAQ,CAER;CACF;CAEA,OAAO;AACT;;;;AAKA,SAAgB,wBAAwB,SAAuC;CAC7E,MAAM,QAAQ,CAAC,QAAQ,IAAI;CAE3B,IAAI,QAAQ,aACV,MAAM,KAAK,KAAK,QAAQ,aAAa;CAGvC,OAAO,MAAM,KAAK,GAAG;AACvB;;;;AAKA,SAAgB,yBAAyB,UAAuE;CAC9G,MAAM,yBAAS,IAAI,IAAoC;CAEvD,KAAK,MAAM,WAAW,UAAU;EAC9B,MAAM,YAAY,QAAQ,aAAa,QAAQ,KAAK,MAAM,GAAG,CAAC,CAAC,MAAM;EAErE,IAAI,CAAC,OAAO,IAAI,SAAS,GACvB,OAAO,IAAI,WAAW,CAAC,CAAC;EAG1B,OAAO,IAAI,SAAS,CAAC,CAAE,KAAK,OAAO;CACrC;CAEA,OAAO;AACT"}

package/dist/utils/stdin-pipe.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Clean up raw piped output so the agent sees readable text, not terminal
+ * control noise.
+ *
+ * 1. Strip all ANSI escape sequences (colors, cursor movement, line clears).
+ * 2. Simulate carriage-return overwrites: for each line, split on `\r` and
+ *    keep only the last segment — this is what the terminal would display
+ *    after a spinner/progress bar finishes.
+ * 3. Collapse runs of blank lines.
+ */
+export declare function sanitizePipedOutput(raw: string): string;
+/**
+ * If stdin is a pipe (not a TTY), read **all** data until EOF and return it as
+ * a string. The returned promise only resolves once the write end of the pipe
+ * is closed — i.e. the sending process has fully exited — so callers are
+ * guaranteed to receive the complete output, not a partial snapshot from a
+ * program that writes progressively.
+ *
+ * Returns `null` when:
+ * - stdin is a TTY (interactive terminal)
+ * - the pipe was empty or contained only whitespace
+ */
+export declare function drainPipedStdin(): Promise<string | null>;
+/**
+ * Reopen `/dev/tty` (or `CON` on Windows) as `process.stdin` so that the
+ * interactive TUI can read keyboard input after the original piped stdin has
+ * been consumed.
+ *
+ * @returns `true` if the swap succeeded, `false` if a TTY could not be opened
+ * (e.g. running in a headless CI container with no controlling terminal).
+ */
+export declare function reopenStdinFromTTY(): boolean;
+//# sourceMappingURL=stdin-pipe.d.ts.map

package/dist/utils/stdin-pipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdin-pipe.d.ts","sourceRoot":"","sources":["../../src/utils/stdin-pipe.ts"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CA0BvD;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA2C9D;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAmB5C"}

package/dist/utils/stdin-pipe.js

@@ -0,0 +1,96 @@
+import * as fs$1 from "fs";
+import * as tty from "tty";
+//#region src/utils/stdin-pipe.ts
+/** Maximum piped input size (1 MB). Content beyond this is truncated. */
+const MAX_PIPE_BYTES = 1024 * 1024;
+/**
+* Matches all ANSI escape sequences — SGR (colors), cursor movement, line
+* clears, scrolling, window titles, etc.
+*/
+const ANSI_RE = /\x1b(?:\[[0-9;?]*[A-Za-z]|\][^\x07\x1b]*(?:\x07|\x1b\\)?|\([A-Z])/g;
+/**
+* Clean up raw piped output so the agent sees readable text, not terminal
+* control noise.
+*
+* 1. Strip all ANSI escape sequences (colors, cursor movement, line clears).
+* 2. Simulate carriage-return overwrites: for each line, split on `\r` and
+*    keep only the last segment — this is what the terminal would display
+*    after a spinner/progress bar finishes.
+* 3. Collapse runs of blank lines.
+*/
+function sanitizePipedOutput(raw) {
+	let text = raw.replace(ANSI_RE, "");
+	text = text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+	text = text.split("\n").map((line) => {
+		if (!line.includes("\r")) return line;
+		const segments = line.split("\r");
+		for (let i = segments.length - 1; i >= 0; i--) if (segments[i].length > 0) return segments[i];
+		return "";
+	}).join("\n");
+	text = text.replace(/\n{3,}/g, "\n\n");
+	return text.trim();
+}
+/**
+* If stdin is a pipe (not a TTY), read **all** data until EOF and return it as
+* a string. The returned promise only resolves once the write end of the pipe
+* is closed — i.e. the sending process has fully exited — so callers are
+* guaranteed to receive the complete output, not a partial snapshot from a
+* program that writes progressively.
+*
+* Returns `null` when:
+* - stdin is a TTY (interactive terminal)
+* - the pipe was empty or contained only whitespace
+*/
+async function drainPipedStdin() {
+	if (process.stdin.isTTY) return null;
+	const chunks = [];
+	let totalBytes = 0;
+	let truncated = false;
+	for await (const chunk of process.stdin) {
+		const buf = chunk;
+		if (totalBytes + buf.length > MAX_PIPE_BYTES) {
+			const remaining = MAX_PIPE_BYTES - totalBytes;
+			if (remaining > 0) chunks.push(Buffer.from(buf.subarray(0, remaining)));
+			buf.fill(0);
+			totalBytes = MAX_PIPE_BYTES;
+			truncated = true;
+			continue;
+		}
+		chunks.push(buf);
+		totalBytes += buf.length;
+	}
+	if (truncated) process.stderr.write(`Warning: Piped input exceeded ${MAX_PIPE_BYTES / 1024 / 1024}MB and was truncated.\n`);
+	const raw = Buffer.concat(chunks).toString("utf-8");
+	for (const buf of chunks) buf.fill(0);
+	chunks.length = 0;
+	const content = sanitizePipedOutput(raw);
+	return content.length > 0 ? content : null;
+}
+/**
+* Reopen `/dev/tty` (or `CON` on Windows) as `process.stdin` so that the
+* interactive TUI can read keyboard input after the original piped stdin has
+* been consumed.
+*
+* @returns `true` if the swap succeeded, `false` if a TTY could not be opened
+* (e.g. running in a headless CI container with no controlling terminal).
+*/
+function reopenStdinFromTTY() {
+	const ttyPath = process.platform === "win32" ? "CON" : "/dev/tty";
+	let fd;
+	try {
+		fd = fs$1.openSync(ttyPath, "r");
+	} catch {
+		return false;
+	}
+	const ttyStream = new tty.ReadStream(fd);
+	Object.defineProperty(process, "stdin", {
+		value: ttyStream,
+		writable: true,
+		configurable: true
+	});
+	return true;
+}
+//#endregion
+export { drainPipedStdin, reopenStdinFromTTY, sanitizePipedOutput };
+
+//# sourceMappingURL=stdin-pipe.js.map

package/dist/utils/stdin-pipe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdin-pipe.js","names":["fs"],"sources":["../../src/utils/stdin-pipe.ts"],"sourcesContent":["import * as fs from 'node:fs';\nimport * as tty from 'node:tty';\n\n/** Maximum piped input size (1 MB). Content beyond this is truncated. */\nconst MAX_PIPE_BYTES = 1024 * 1024;\n\n/**\n * Matches all ANSI escape sequences — SGR (colors), cursor movement, line\n * clears, scrolling, window titles, etc.\n */\nconst ANSI_RE = /\\x1b(?:\\[[0-9;?]*[A-Za-z]|\\][^\\x07\\x1b]*(?:\\x07|\\x1b\\\\)?|\\([A-Z])/g;\n\n/**\n * Clean up raw piped output so the agent sees readable text, not terminal\n * control noise.\n *\n * 1. Strip all ANSI escape sequences (colors, cursor movement, line clears).\n * 2. Simulate carriage-return overwrites: for each line, split on `\\r` and\n *    keep only the last segment — this is what the terminal would display\n *    after a spinner/progress bar finishes.\n * 3. Collapse runs of blank lines.\n */\nexport function sanitizePipedOutput(raw: string): string {\n  // Strip ANSI escapes first\n  let text = raw.replace(ANSI_RE, '');\n\n  // Strip binary control characters (everything below 0x20 except \\t, \\n, \\r)\n  text = text.replace(/[\\x00-\\x08\\x0B\\x0C\\x0E-\\x1F\\x7F]/g, '');\n\n  // Simulate \\r overwrites: for each line, the last \\r-segment wins\n  text = text\n    .split('\\n')\n    .map(line => {\n      if (!line.includes('\\r')) return line;\n      const segments = line.split('\\r');\n      // Walk backwards to find the last non-empty segment — a trailing \\r\n      // produces an empty final segment that would otherwise discard visible text.\n      for (let i = segments.length - 1; i >= 0; i--) {\n        if (segments[i]!.length > 0) return segments[i]!;\n      }\n      return '';\n    })\n    .join('\\n');\n\n  // Collapse 3+ consecutive blank lines into 2\n  text = text.replace(/\\n{3,}/g, '\\n\\n');\n\n  return text.trim();\n}\n\n/**\n * If stdin is a pipe (not a TTY), read **all** data until EOF and return it as\n * a string. The returned promise only resolves once the write end of the pipe\n * is closed — i.e. the sending process has fully exited — so callers are\n * guaranteed to receive the complete output, not a partial snapshot from a\n * program that writes progressively.\n *\n * Returns `null` when:\n * - stdin is a TTY (interactive terminal)\n * - the pipe was empty or contained only whitespace\n */\nexport async function drainPipedStdin(): Promise<string | null> {\n  if (process.stdin.isTTY) return null;\n\n  const chunks: Buffer[] = [];\n  let totalBytes = 0;\n  let truncated = false;\n\n  for await (const chunk of process.stdin) {\n    const buf = chunk as Buffer;\n\n    if (totalBytes + buf.length > MAX_PIPE_BYTES) {\n      // Take only what fits under the cap — copy so we don't retain the\n      // original backing buffer, then zero the source.\n      const remaining = MAX_PIPE_BYTES - totalBytes;\n      if (remaining > 0) {\n        chunks.push(Buffer.from(buf.subarray(0, remaining)));\n      }\n      buf.fill(0);\n      totalBytes = MAX_PIPE_BYTES;\n      truncated = true;\n      // Keep draining so we don't leave unread data in the pipe, but don't\n      // store it — we still need to wait for EOF.\n      continue;\n    }\n\n    chunks.push(buf);\n    totalBytes += buf.length;\n  }\n\n  if (truncated) {\n    process.stderr.write(`Warning: Piped input exceeded ${MAX_PIPE_BYTES / 1024 / 1024}MB and was truncated.\\n`);\n  }\n\n  const raw = Buffer.concat(chunks).toString('utf-8');\n\n  // Zero out raw buffers so piped secrets don't linger in memory\n  for (const buf of chunks) {\n    buf.fill(0);\n  }\n  chunks.length = 0;\n\n  const content = sanitizePipedOutput(raw);\n  return content.length > 0 ? content : null;\n}\n\n/**\n * Reopen `/dev/tty` (or `CON` on Windows) as `process.stdin` so that the\n * interactive TUI can read keyboard input after the original piped stdin has\n * been consumed.\n *\n * @returns `true` if the swap succeeded, `false` if a TTY could not be opened\n * (e.g. running in a headless CI container with no controlling terminal).\n */\nexport function reopenStdinFromTTY(): boolean {\n  const ttyPath = process.platform === 'win32' ? 'CON' : '/dev/tty';\n\n  let fd: number;\n  try {\n    fd = fs.openSync(ttyPath, 'r');\n  } catch {\n    return false;\n  }\n\n  const ttyStream = new tty.ReadStream(fd);\n\n  Object.defineProperty(process, 'stdin', {\n    value: ttyStream,\n    writable: true,\n    configurable: true,\n  });\n\n  return true;\n}\n"],"mappings":";;;;AAIA,MAAM,iBAAiB,OAAO;;;;;AAM9B,MAAM,UAAU;;;;;;;;;;;AAYhB,SAAgB,oBAAoB,KAAqB;CAEvD,IAAI,OAAO,IAAI,QAAQ,SAAS,EAAE;CAGlC,OAAO,KAAK,QAAQ,qCAAqC,EAAE;CAG3D,OAAO,KACJ,MAAM,IAAI,CAAC,CACX,KAAI,SAAQ;EACX,IAAI,CAAC,KAAK,SAAS,IAAI,GAAG,OAAO;EACjC,MAAM,WAAW,KAAK,MAAM,IAAI;EAGhC,KAAK,IAAI,IAAI,SAAS,SAAS,GAAG,KAAK,GAAG,KACxC,IAAI,SAAS,EAAE,CAAE,SAAS,GAAG,OAAO,SAAS;EAE/C,OAAO;CACT,CAAC,CAAC,CACD,KAAK,IAAI;CAGZ,OAAO,KAAK,QAAQ,WAAW,MAAM;CAErC,OAAO,KAAK,KAAK;AACnB;;;;;;;;;;;;AAaA,eAAsB,kBAA0C;CAC9D,IAAI,QAAQ,MAAM,OAAO,OAAO;CAEhC,MAAM,SAAmB,CAAC;CAC1B,IAAI,aAAa;CACjB,IAAI,YAAY;CAEhB,WAAW,MAAM,SAAS,QAAQ,OAAO;EACvC,MAAM,MAAM;EAEZ,IAAI,aAAa,IAAI,SAAS,gBAAgB;GAG5C,MAAM,YAAY,iBAAiB;GACnC,IAAI,YAAY,GACd,OAAO,KAAK,OAAO,KAAK,IAAI,SAAS,GAAG,SAAS,CAAC,CAAC;GAErD,IAAI,KAAK,CAAC;GACV,aAAa;GACb,YAAY;GAGZ;EACF;EAEA,OAAO,KAAK,GAAG;EACf,cAAc,IAAI;CACpB;CAEA,IAAI,WACF,QAAQ,OAAO,MAAM,iCAAiC,iBAAiB,OAAO,KAAK,wBAAwB;CAG7G,MAAM,MAAM,OAAO,OAAO,MAAM,CAAC,CAAC,SAAS,OAAO;CAGlD,KAAK,MAAM,OAAO,QAChB,IAAI,KAAK,CAAC;CAEZ,OAAO,SAAS;CAEhB,MAAM,UAAU,oBAAoB,GAAG;CACvC,OAAO,QAAQ,SAAS,IAAI,UAAU;AACxC;;;;;;;;;AAUA,SAAgB,qBAA8B;CAC5C,MAAM,UAAU,QAAQ,aAAa,UAAU,QAAQ;CAEvD,IAAI;CACJ,IAAI;EACF,KAAKA,KAAG,SAAS,SAAS,GAAG;CAC/B,QAAQ;EACN,OAAO;CACT;CAEA,MAAM,YAAY,IAAI,IAAI,WAAW,EAAE;CAEvC,OAAO,eAAe,SAAS,SAAS;EACtC,OAAO;EACP,UAAU;EACV,cAAc;CAChB,CAAC;CAED,OAAO;AACT"}

package/dist/utils/storage-factory.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Storage factory — creates the appropriate storage backend based on resolved config.
+ *
+ * If PG is selected but fails to connect, falls back to LibSQL so the TUI
+ * can start and the user can fix the connection via /settings.
+ */
+import type { MastraCompositeStore, RetentionConfig } from '@mastra/core/storage';
+import type { MastraVector } from '@mastra/core/vector';
+import type { StorageConfig } from './project.js';
+export declare const MASTRA_CODE_LOCAL_PRAGMAS: {
+    cacheSize: number;
+    mmapSize: number;
+};
+/**
+ * Construct a LibSQL store for an arbitrary url/authToken, applying the same
+ * local pragmas the default factory uses.
+ */
+export declare function buildLibSQLStore(opts: {
+    id?: string;
+    url: string;
+    authToken?: string;
+    retention?: RetentionConfig;
+}): MastraCompositeStore;
+/** Construct a LibSQL vector store for an arbitrary url/authToken. */
+export declare function buildLibSQLVector(opts: {
+    id?: string;
+    url: string;
+    authToken?: string;
+}): MastraVector;
+export interface StorageResult {
+    storage: MastraCompositeStore;
+    /** The effective backend after any fallback logic has run. */
+    backend: 'libsql' | 'pg';
+    /** Non-null when PG was requested but failed — contains a user-facing warning. */
+    warning?: string;
+}
+/**
+ * Create a storage instance from the resolved config.
+ *
+ * - `libsql` backend → LibSQLStore (always available)
+ * - `pg` backend → PostgresStore, falls back to LibSQL on connection failure
+ */
+export declare function createStorage(config: StorageConfig): Promise<StorageResult>;
+/**
+ * Create a vector store for recall search.
+ * Uses a separate LibSQL file to avoid bloating the main storage DB with embedding data.
+ * For PG backends, reuses the same connection (PG handles the extra tables fine).
+ */
+export declare function createVectorStore(config: StorageConfig, effectiveBackend?: 'libsql' | 'pg'): Promise<MastraVector | undefined>;
+//# sourceMappingURL=storage-factory.d.ts.map

package/dist/utils/storage-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-factory.d.ts","sourceRoot":"","sources":["../../src/utils/storage-factory.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAClF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAIxD,OAAO,KAAK,EAAE,aAAa,EAAmB,MAAM,cAAc,CAAC;AAInE,eAAO,MAAM,yBAAyB;;;CAGrC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IACrC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,eAAe,CAAC;CAC7B,GAAG,oBAAoB,CAQvB;AAED,sEAAsE;AACtE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,YAAY,CAMtG;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,oBAAoB,CAAC;IAC9B,8DAA8D;IAC9D,OAAO,EAAE,QAAQ,GAAG,IAAI,CAAC;IACzB,kFAAkF;IAClF,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAMD;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAUjF;AAyDD;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,aAAa,EACrB,gBAAgB,GAAE,QAAQ,GAAG,IAAqB,GACjD,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAuBnC"}

package/dist/utils/storage-factory.js

@@ -0,0 +1,121 @@
+import { getDatabasePath, getVectorDatabasePath } from "./project.js";
+import { DEFAULT_RETENTION } from "./storage-maintenance.js";
+import { LibSQLStore, LibSQLVector } from "@mastra/libsql";
+import { PostgresStore } from "@mastra/pg";
+//#region src/utils/storage-factory.ts
+const MASTRA_CODE_LOCAL_PRAGMAS = {
+	cacheSize: -128e3,
+	mmapSize: 536870912
+};
+/**
+* Construct a LibSQL store for an arbitrary url/authToken, applying the same
+* local pragmas the default factory uses.
+*/
+function buildLibSQLStore(opts) {
+	return new LibSQLStore({
+		id: opts.id ?? "mastra-code-storage",
+		url: opts.url,
+		...opts.authToken ? { authToken: opts.authToken } : {},
+		...opts.retention ? { retention: opts.retention } : {},
+		localPragmas: MASTRA_CODE_LOCAL_PRAGMAS
+	});
+}
+/** Construct a LibSQL vector store for an arbitrary url/authToken. */
+function buildLibSQLVector(opts) {
+	return new LibSQLVector({
+		id: opts.id ?? "mastra-code-vectors",
+		url: opts.url,
+		...opts.authToken ? { authToken: opts.authToken } : {}
+	});
+}
+function createFallbackLibSQL() {
+	return buildLibSQLStore({
+		url: `file:${getDatabasePath()}`,
+		retention: DEFAULT_RETENTION
+	});
+}
+/**
+* Create a storage instance from the resolved config.
+*
+* - `libsql` backend → LibSQLStore (always available)
+* - `pg` backend → PostgresStore, falls back to LibSQL on connection failure
+*/
+async function createStorage(config) {
+	if (config.backend === "pg") return createPgStorage(config);
+	return {
+		storage: buildLibSQLStore({
+			url: config.url,
+			authToken: config.authToken,
+			retention: DEFAULT_RETENTION
+		}),
+		backend: "libsql"
+	};
+}
+async function createPgStorage(config) {
+	if (!config.connectionString && !config.host) return {
+		storage: createFallbackLibSQL(),
+		backend: "libsql",
+		warning: "PostgreSQL backend selected but no connection info configured. Using LibSQL fallback. Set a connection string via /settings."
+	};
+	const base = {
+		id: "mastra-code-storage",
+		retention: DEFAULT_RETENTION,
+		...config.schemaName ? { schemaName: config.schemaName } : {},
+		...config.disableInit ? { disableInit: config.disableInit } : {},
+		...config.skipDefaultIndexes ? { skipDefaultIndexes: config.skipDefaultIndexes } : {}
+	};
+	const store = config.connectionString ? new PostgresStore({
+		...base,
+		connectionString: config.connectionString
+	}) : new PostgresStore({
+		...base,
+		host: config.host,
+		port: config.port,
+		database: config.database,
+		user: config.user,
+		password: config.password
+	});
+	try {
+		await store.init();
+	} catch (err) {
+		const msg = err?.message ?? String(err);
+		const target = config.connectionString ?? `${config.host}:${config.port ?? 5432}`;
+		try {
+			await store.close();
+		} catch {}
+		return {
+			storage: createFallbackLibSQL(),
+			backend: "libsql",
+			warning: `Failed to connect to PostgreSQL at ${target}: ${msg}\nUsing LibSQL fallback. Fix the connection via /settings.`
+		};
+	}
+	return {
+		storage: store,
+		backend: "pg"
+	};
+}
+/**
+* Create a vector store for recall search.
+* Uses a separate LibSQL file to avoid bloating the main storage DB with embedding data.
+* For PG backends, reuses the same connection (PG handles the extra tables fine).
+*/
+async function createVectorStore(config, effectiveBackend = config.backend) {
+	if (effectiveBackend === "pg") {
+		const pgConfig = config;
+		if (!pgConfig.connectionString && !pgConfig.host) return void 0;
+		const { PgVector } = await import("@mastra/pg");
+		return new PgVector({
+			id: "mastra-code-vectors",
+			connectionString: pgConfig.connectionString ?? `postgresql://${pgConfig.user}:${pgConfig.password}@${pgConfig.host}:${pgConfig.port ?? 5432}/${pgConfig.database}`
+		});
+	}
+	const libsqlConfig = config;
+	return buildLibSQLVector({
+		url: libsqlConfig.vectorUrl ?? `file:${getVectorDatabasePath()}`,
+		authToken: libsqlConfig.vectorAuthToken
+	});
+}
+//#endregion
+export { MASTRA_CODE_LOCAL_PRAGMAS, buildLibSQLStore, buildLibSQLVector, createStorage, createVectorStore };
+
+//# sourceMappingURL=storage-factory.js.map