@thiagodiogo/pscode 1.0.0

package/dist/core/collections/runtime.d.ts

@@ -0,0 +1,46 @@
+export type CollectionMetadata = Readonly<Record<string, unknown>>;
+export type CollectionHooks = Readonly<Record<string, unknown>>;
+export interface CollectionDefinition<THandle = unknown> {
+    id: string;
+    mount: string;
+    metadata?: CollectionMetadata;
+    hooks?: CollectionHooks;
+    createHandle?: (context: MountedCollectionContext) => THandle;
+}
+export interface CollectionRegistry {
+    list(): readonly CollectionDefinition[];
+    get<THandle = unknown>(collectionId: string): CollectionDefinition<THandle> | undefined;
+    require<THandle = unknown>(collectionId: string): CollectionDefinition<THandle>;
+}
+export interface MountedCollectionContext {
+    storeRoot: string;
+    collectionId: string;
+    mount: string;
+    mountRoot: string;
+    resolvePath(relativePath?: string): string;
+    toStorePath(relativePath?: string): string;
+}
+export interface MountedCollection<THandle = unknown> {
+    collectionId: string;
+    mount: string;
+    mountRoot: string;
+    context: MountedCollectionContext;
+    handle: THandle | undefined;
+    resolvePath(relativePath?: string): string;
+    toStorePath(relativePath?: string): string;
+}
+export interface MountedCollectionRegistry {
+    list(): readonly MountedCollection[];
+    get<THandle = unknown>(collectionId: string): MountedCollection<THandle> | undefined;
+    require<THandle = unknown>(collectionId: string): MountedCollection<THandle>;
+}
+export interface MountCollectionsInput {
+    storeRoot: string;
+    collections: CollectionRegistry;
+}
+export declare function validateCollectionId(id: string): string;
+export declare function validateMount(mount: string): string;
+export declare function parseCollectionPath(input?: string): string;
+export declare function createCollectionRegistry(definitions: readonly CollectionDefinition[]): CollectionRegistry;
+export declare function mountCollections(input: MountCollectionsInput): MountedCollectionRegistry;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/core/collections/runtime.js

@@ -0,0 +1,194 @@
+import * as path from 'node:path';
+import { FileSystemUtils } from '../../utils/file-system.js';
+function assertNoNul(value, label) {
+    if (value.includes('\0')) {
+        throw new Error(`${label} must not contain NUL bytes`);
+    }
+}
+function validateKebabSegment(value, label) {
+    assertNoNul(value, label);
+    if (value.length === 0) {
+        throw new Error(`${label} must not be empty`);
+    }
+    if (value === '.' || value === '..') {
+        throw new Error(`${label} must not be '${value}'`);
+    }
+    if (/[\\/]/u.test(value)) {
+        throw new Error(`${label} must not contain path separators`);
+    }
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(value)) {
+        throw new Error(`${label} must be kebab-case with lowercase letters, numbers, and single hyphen separators`);
+    }
+    return value;
+}
+export function validateCollectionId(id) {
+    return validateKebabSegment(id, 'Collection id');
+}
+export function validateMount(mount) {
+    assertNoNul(mount, 'Collection mount');
+    if (mount.startsWith('.')) {
+        throw new Error(`Collection mount '${mount}' is reserved`);
+    }
+    return validateKebabSegment(mount, 'Collection mount');
+}
+function isWindowsDrivePath(value) {
+    return /^[A-Za-z]:/u.test(value);
+}
+function isUncPath(value) {
+    return value.startsWith('\\\\') || value.startsWith('//');
+}
+export function parseCollectionPath(input = '') {
+    assertNoNul(input, 'Collection path');
+    if (input.length === 0) {
+        return '';
+    }
+    if (input.includes('\\')) {
+        throw new Error('Collection path must use forward slashes');
+    }
+    if (isWindowsDrivePath(input)) {
+        throw new Error('Collection path must not be a Windows drive path');
+    }
+    if (isUncPath(input) || path.posix.isAbsolute(input)) {
+        throw new Error('Collection path must be relative');
+    }
+    const segments = input.split('/');
+    for (const segment of segments) {
+        if (segment.length === 0) {
+            throw new Error('Collection path must not contain empty segments');
+        }
+        if (segment === '.' || segment === '..') {
+            throw new Error('Collection path must not contain dot segments');
+        }
+    }
+    return segments.join('/');
+}
+function compareCollectionDefinitions(a, b) {
+    return a.id.localeCompare(b.id);
+}
+export function createCollectionRegistry(definitions) {
+    const byId = new Map();
+    const mountOwners = new Map();
+    for (const definition of definitions) {
+        const id = validateCollectionId(definition.id);
+        const mount = validateMount(definition.mount);
+        if (byId.has(id)) {
+            throw new Error(`Duplicate collection id '${id}'`);
+        }
+        const existingMountOwner = mountOwners.get(mount);
+        if (existingMountOwner) {
+            throw new Error(`Duplicate collection mount '${mount}' for '${existingMountOwner}' and '${id}'`);
+        }
+        const normalizedDefinition = {
+            ...definition,
+            id,
+            mount,
+        };
+        byId.set(id, normalizedDefinition);
+        mountOwners.set(mount, id);
+    }
+    const sortedDefinitions = Array.from(byId.values()).sort(compareCollectionDefinitions);
+    return {
+        list() {
+            return [...sortedDefinitions];
+        },
+        get(collectionId) {
+            const id = validateCollectionId(collectionId);
+            return byId.get(id);
+        },
+        require(collectionId) {
+            const definition = this.get(collectionId);
+            if (!definition) {
+                throw new Error(`Unknown collection '${collectionId}'`);
+            }
+            return definition;
+        },
+    };
+}
+function isWindowsLikePath(candidatePath) {
+    return /^[A-Za-z]:[\\/]/u.test(candidatePath) || candidatePath.startsWith('\\\\');
+}
+function relativePath(fromPath, toPath) {
+    if (isWindowsLikePath(fromPath) || isWindowsLikePath(toPath)) {
+        return path.win32.relative(path.win32.normalize(fromPath), path.win32.normalize(toPath));
+    }
+    return path.posix.relative(fromPath.replace(/\\/g, '/'), toPath.replace(/\\/g, '/'));
+}
+function isRelativePathAbsolute(value, windowsLike) {
+    return windowsLike ? path.win32.isAbsolute(value) : path.posix.isAbsolute(value);
+}
+function isSameOrDescendant(rootPath, candidatePath) {
+    const windowsLike = isWindowsLikePath(rootPath) || isWindowsLikePath(candidatePath);
+    const relative = relativePath(rootPath, candidatePath);
+    const escapesRoot = /^\.\.(?:[\\/]|$)/u.test(relative);
+    return (relative === '' ||
+        (!escapesRoot && !isRelativePathAbsolute(relative, windowsLike)));
+}
+function getMountRoot(storeRoot, mount) {
+    return FileSystemUtils.joinPath(storeRoot, validateMount(mount));
+}
+function resolvePathInsideMount(mountRoot, relativePath) {
+    const collectionPath = parseCollectionPath(relativePath);
+    const resolvedPath = collectionPath.length > 0
+        ? FileSystemUtils.joinPath(mountRoot, collectionPath)
+        : mountRoot;
+    if (!isSameOrDescendant(mountRoot, resolvedPath)) {
+        throw new Error(`Collection path escapes mount: ${relativePath ?? ''}`);
+    }
+    return resolvedPath;
+}
+function toStorePath(mount, relativePath) {
+    const collectionPath = parseCollectionPath(relativePath);
+    return collectionPath.length > 0
+        ? `${validateMount(mount)}/${collectionPath}`
+        : validateMount(mount);
+}
+function createMountedCollection(storeRoot, definition) {
+    const mountRoot = getMountRoot(storeRoot, definition.mount);
+    const resolveMountedPath = (relativePath) => resolvePathInsideMount(mountRoot, relativePath);
+    const resolveStorePath = (relativePath) => toStorePath(definition.mount, relativePath);
+    const context = {
+        storeRoot,
+        collectionId: definition.id,
+        mount: definition.mount,
+        mountRoot,
+        resolvePath: resolveMountedPath,
+        toStorePath: resolveStorePath,
+    };
+    return {
+        collectionId: definition.id,
+        mount: definition.mount,
+        mountRoot,
+        context,
+        handle: definition.createHandle?.(context),
+        resolvePath: resolveMountedPath,
+        toStorePath: resolveStorePath,
+    };
+}
+export function mountCollections(input) {
+    if (input.storeRoot.length === 0) {
+        throw new Error('Context store root must not be empty');
+    }
+    const byId = new Map();
+    for (const definition of input.collections.list()) {
+        const mountedCollection = createMountedCollection(input.storeRoot, definition);
+        byId.set(mountedCollection.collectionId, mountedCollection);
+    }
+    const sortedCollections = Array.from(byId.values()).sort((a, b) => a.collectionId.localeCompare(b.collectionId));
+    return {
+        list() {
+            return [...sortedCollections];
+        },
+        get(collectionId) {
+            const id = validateCollectionId(collectionId);
+            return byId.get(id);
+        },
+        require(collectionId) {
+            const mountedCollection = this.get(collectionId);
+            if (!mountedCollection) {
+                throw new Error(`Unknown mounted collection '${collectionId}'`);
+            }
+            return mountedCollection;
+        },
+    };
+}
+//# sourceMappingURL=runtime.js.map

package/dist/core/command-generation/adapters/claude.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Claude Code Command Adapter
+ *
+ * Formats commands for Claude Code following its frontmatter specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Claude Code adapter for command generation.
+ * File path: .claude/commands/ps/<id>.md
+ * Frontmatter: name, description, category, tags
+ */
+export declare const claudeAdapter: ToolCommandAdapter;
+//# sourceMappingURL=claude.d.ts.map

package/dist/core/command-generation/adapters/claude.js

@@ -0,0 +1,50 @@
+/**
+ * Claude Code Command Adapter
+ *
+ * Formats commands for Claude Code following its frontmatter specification.
+ */
+import path from 'path';
+/**
+ * Escapes a string value for safe YAML output.
+ * Quotes the string if it contains special YAML characters.
+ */
+function escapeYamlValue(value) {
+    // Check if value needs quoting (contains special YAML characters or starts/ends with whitespace)
+    const needsQuoting = /[:\n\r#{}[\],&*!|>'"%@`]|^\s|\s$/.test(value);
+    if (needsQuoting) {
+        // Use double quotes and escape internal double quotes and backslashes
+        const escaped = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+        return `"${escaped}"`;
+    }
+    return value;
+}
+/**
+ * Formats a tags array as a YAML array with proper escaping.
+ */
+function formatTagsArray(tags) {
+    const escapedTags = tags.map((tag) => escapeYamlValue(tag));
+    return `[${escapedTags.join(', ')}]`;
+}
+/**
+ * Claude Code adapter for command generation.
+ * File path: .claude/commands/ps/<id>.md
+ * Frontmatter: name, description, category, tags
+ */
+export const claudeAdapter = {
+    toolId: 'claude',
+    getFilePath(commandId) {
+        return path.join('.claude', 'commands', 'ps', `${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+name: ${escapeYamlValue(content.name)}
+description: ${escapeYamlValue(content.description)}
+category: ${escapeYamlValue(content.category)}
+tags: ${formatTagsArray(content.tags)}
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=claude.js.map

package/dist/core/command-generation/adapters/codex.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Codex Command Adapter
+ *
+ * Formats commands for Codex following its frontmatter specification.
+ * Codex custom prompts live in the global home directory (~/.codex/prompts/)
+ * and are not shared through the repository. The CODEX_HOME env var can
+ * override the default ~/.codex location.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Codex adapter for command generation.
+ * File path: <CODEX_HOME>/prompts/ps-<id>.md (absolute, global)
+ * Frontmatter: description, argument-hint
+ */
+export declare const codexAdapter: ToolCommandAdapter;
+//# sourceMappingURL=codex.d.ts.map

package/dist/core/command-generation/adapters/codex.js

@@ -0,0 +1,39 @@
+/**
+ * Codex Command Adapter
+ *
+ * Formats commands for Codex following its frontmatter specification.
+ * Codex custom prompts live in the global home directory (~/.codex/prompts/)
+ * and are not shared through the repository. The CODEX_HOME env var can
+ * override the default ~/.codex location.
+ */
+import os from 'os';
+import path from 'path';
+/**
+ * Returns the Codex home directory.
+ * Respects the CODEX_HOME env var, defaulting to ~/.codex.
+ */
+function getCodexHome() {
+    const envHome = process.env.CODEX_HOME?.trim();
+    return path.resolve(envHome ? envHome : path.join(os.homedir(), '.codex'));
+}
+/**
+ * Codex adapter for command generation.
+ * File path: <CODEX_HOME>/prompts/ps-<id>.md (absolute, global)
+ * Frontmatter: description, argument-hint
+ */
+export const codexAdapter = {
+    toolId: 'codex',
+    getFilePath(commandId) {
+        return path.join(getCodexHome(), 'prompts', `ps-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+description: ${content.description}
+argument-hint: command arguments
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=codex.js.map

package/dist/core/command-generation/adapters/cursor.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Cursor Command Adapter
+ *
+ * Formats commands for Cursor following its frontmatter specification.
+ * Cursor uses a different frontmatter format and file naming convention.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Cursor adapter for command generation.
+ * File path: .cursor/commands/ps-<id>.md
+ * Frontmatter: name (as /ps-<id>), id, category, description
+ */
+export declare const cursorAdapter: ToolCommandAdapter;
+//# sourceMappingURL=cursor.d.ts.map

package/dist/core/command-generation/adapters/cursor.js

@@ -0,0 +1,44 @@
+/**
+ * Cursor Command Adapter
+ *
+ * Formats commands for Cursor following its frontmatter specification.
+ * Cursor uses a different frontmatter format and file naming convention.
+ */
+import path from 'path';
+/**
+ * Escapes a string value for safe YAML output.
+ * Quotes the string if it contains special YAML characters.
+ */
+function escapeYamlValue(value) {
+    // Check if value needs quoting (contains special YAML characters or starts/ends with whitespace)
+    const needsQuoting = /[:\n\r#{}[\],&*!|>'"%@`]|^\s|\s$/.test(value);
+    if (needsQuoting) {
+        // Use double quotes and escape internal double quotes and backslashes
+        const escaped = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+        return `"${escaped}"`;
+    }
+    return value;
+}
+/**
+ * Cursor adapter for command generation.
+ * File path: .cursor/commands/ps-<id>.md
+ * Frontmatter: name (as /ps-<id>), id, category, description
+ */
+export const cursorAdapter = {
+    toolId: 'cursor',
+    getFilePath(commandId) {
+        return path.join('.cursor', 'commands', `ps-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+name: /ps-${content.id}
+id: ps-${content.id}
+category: ${escapeYamlValue(content.category)}
+description: ${escapeYamlValue(content.description)}
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=cursor.js.map

package/dist/core/command-generation/adapters/gemini.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Gemini CLI Command Adapter
+ *
+ * Formats commands for Gemini CLI following its TOML specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Gemini adapter for command generation.
+ * File path: .gemini/commands/ps/<id>.toml
+ * Format: TOML with description and prompt fields
+ */
+export declare const geminiAdapter: ToolCommandAdapter;
+//# sourceMappingURL=gemini.d.ts.map

package/dist/core/command-generation/adapters/gemini.js

@@ -0,0 +1,26 @@
+/**
+ * Gemini CLI Command Adapter
+ *
+ * Formats commands for Gemini CLI following its TOML specification.
+ */
+import path from 'path';
+/**
+ * Gemini adapter for command generation.
+ * File path: .gemini/commands/ps/<id>.toml
+ * Format: TOML with description and prompt fields
+ */
+export const geminiAdapter = {
+    toolId: 'gemini',
+    getFilePath(commandId) {
+        return path.join('.gemini', 'commands', 'ps', `${commandId}.toml`);
+    },
+    formatFile(content) {
+        return `description = "${content.description}"
+
+prompt = """
+${content.body}
+"""
+`;
+    },
+};
+//# sourceMappingURL=gemini.js.map

package/dist/core/command-generation/adapters/github-copilot.d.ts

@@ -0,0 +1,13 @@
+/**
+ * GitHub Copilot Command Adapter
+ *
+ * Formats commands for GitHub Copilot following its .prompt.md specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * GitHub Copilot adapter for command generation.
+ * File path: .github/prompts/ps-<id>.prompt.md
+ * Frontmatter: description
+ */
+export declare const githubCopilotAdapter: ToolCommandAdapter;
+//# sourceMappingURL=github-copilot.d.ts.map

package/dist/core/command-generation/adapters/github-copilot.js

@@ -0,0 +1,26 @@
+/**
+ * GitHub Copilot Command Adapter
+ *
+ * Formats commands for GitHub Copilot following its .prompt.md specification.
+ */
+import path from 'path';
+/**
+ * GitHub Copilot adapter for command generation.
+ * File path: .github/prompts/ps-<id>.prompt.md
+ * Frontmatter: description
+ */
+export const githubCopilotAdapter = {
+    toolId: 'github-copilot',
+    getFilePath(commandId) {
+        return path.join('.github', 'prompts', `ps-${commandId}.prompt.md`);
+    },
+    formatFile(content) {
+        return `---
+description: ${content.description}
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=github-copilot.js.map

package/dist/core/command-generation/adapters/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Command Adapters Index
+ *
+ * Re-exports all tool command adapters.
+ */
+export { claudeAdapter } from './claude.js';
+export { codexAdapter } from './codex.js';
+export { cursorAdapter } from './cursor.js';
+export { geminiAdapter } from './gemini.js';
+export { githubCopilotAdapter } from './github-copilot.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/command-generation/adapters/index.js

@@ -0,0 +1,11 @@
+/**
+ * Command Adapters Index
+ *
+ * Re-exports all tool command adapters.
+ */
+export { claudeAdapter } from './claude.js';
+export { codexAdapter } from './codex.js';
+export { cursorAdapter } from './cursor.js';
+export { geminiAdapter } from './gemini.js';
+export { githubCopilotAdapter } from './github-copilot.js';
+//# sourceMappingURL=index.js.map

package/dist/core/command-generation/generator.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Command Generator
+ *
+ * Functions for generating command files using tool adapters.
+ */
+import type { CommandContent, ToolCommandAdapter, GeneratedCommand } from './types.js';
+/**
+ * Generate a single command file using the provided adapter.
+ * @param content - The tool-agnostic command content
+ * @param adapter - The tool-specific adapter
+ * @returns Generated command with path and file content
+ */
+export declare function generateCommand(content: CommandContent, adapter: ToolCommandAdapter): GeneratedCommand;
+/**
+ * Generate multiple command files using the provided adapter.
+ * @param contents - Array of tool-agnostic command contents
+ * @param adapter - The tool-specific adapter
+ * @returns Array of generated commands with paths and file contents
+ */
+export declare function generateCommands(contents: CommandContent[], adapter: ToolCommandAdapter): GeneratedCommand[];
+//# sourceMappingURL=generator.d.ts.map

package/dist/core/command-generation/generator.js

@@ -0,0 +1,27 @@
+/**
+ * Command Generator
+ *
+ * Functions for generating command files using tool adapters.
+ */
+/**
+ * Generate a single command file using the provided adapter.
+ * @param content - The tool-agnostic command content
+ * @param adapter - The tool-specific adapter
+ * @returns Generated command with path and file content
+ */
+export function generateCommand(content, adapter) {
+    return {
+        path: adapter.getFilePath(content.id),
+        fileContent: adapter.formatFile(content),
+    };
+}
+/**
+ * Generate multiple command files using the provided adapter.
+ * @param contents - Array of tool-agnostic command contents
+ * @param adapter - The tool-specific adapter
+ * @returns Array of generated commands with paths and file contents
+ */
+export function generateCommands(contents, adapter) {
+    return contents.map((content) => generateCommand(content, adapter));
+}
+//# sourceMappingURL=generator.js.map

package/dist/core/command-generation/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Command Generation Module
+ *
+ * Generic command generation system with tool-specific adapters.
+ *
+ * Usage:
+ * ```typescript
+ * import { generateCommands, CommandAdapterRegistry, type CommandContent } from './command-generation/index.js';
+ *
+ * const contents: CommandContent[] = [...];
+ * const adapter = CommandAdapterRegistry.get('cursor');
+ * if (adapter) {
+ *   const commands = generateCommands(contents, adapter);
+ *   // Write commands to disk
+ * }
+ * ```
+ */
+export type { CommandContent, ToolCommandAdapter, GeneratedCommand, } from './types.js';
+export { CommandAdapterRegistry } from './registry.js';
+export { generateCommand, generateCommands } from './generator.js';
+export { claudeAdapter, codexAdapter, cursorAdapter, geminiAdapter, githubCopilotAdapter } from './adapters/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/command-generation/index.js

@@ -0,0 +1,24 @@
+/**
+ * Command Generation Module
+ *
+ * Generic command generation system with tool-specific adapters.
+ *
+ * Usage:
+ * ```typescript
+ * import { generateCommands, CommandAdapterRegistry, type CommandContent } from './command-generation/index.js';
+ *
+ * const contents: CommandContent[] = [...];
+ * const adapter = CommandAdapterRegistry.get('cursor');
+ * if (adapter) {
+ *   const commands = generateCommands(contents, adapter);
+ *   // Write commands to disk
+ * }
+ * ```
+ */
+// Registry
+export { CommandAdapterRegistry } from './registry.js';
+// Generator functions
+export { generateCommand, generateCommands } from './generator.js';
+// Adapters (for direct access if needed)
+export { claudeAdapter, codexAdapter, cursorAdapter, geminiAdapter, githubCopilotAdapter } from './adapters/index.js';
+//# sourceMappingURL=index.js.map

package/dist/core/command-generation/registry.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Command Adapter Registry
+ *
+ * Centralized registry for tool command adapters.
+ */
+import type { ToolCommandAdapter } from './types.js';
+/**
+ * Registry for looking up tool command adapters.
+ */
+export declare class CommandAdapterRegistry {
+    private static adapters;
+    /**
+     * Register a tool command adapter.
+     * @param adapter - The adapter to register
+     */
+    static register(adapter: ToolCommandAdapter): void;
+    /**
+     * Get an adapter by tool ID.
+     * @param toolId - The tool identifier (e.g., 'claude', 'cursor')
+     * @returns The adapter or undefined if not registered
+     */
+    static get(toolId: string): ToolCommandAdapter | undefined;
+    /**
+     * Get all registered adapters.
+     * @returns Array of all registered adapters
+     */
+    static getAll(): ToolCommandAdapter[];
+    /**
+     * Check if an adapter is registered for a tool.
+     * @param toolId - The tool identifier
+     * @returns True if an adapter exists
+     */
+    static has(toolId: string): boolean;
+}
+//# sourceMappingURL=registry.d.ts.map