@revealui/ai 0.1.0

package/dist/skills/types.js

@@ -0,0 +1,176 @@
+/**
+ * Skill Types
+ *
+ * Zod schemas and types for Agent Skills (skills.sh ecosystem).
+ * Skills are instruction packages that agents can discover and use.
+ */
+import { z } from 'zod/v4';
+/**
+ * Allowed tools specification.
+ * Format: "ToolName" or "ToolName(pattern:*)" for filtered access.
+ */
+export const AllowedToolSchema = z.union([
+    z.string(), // Simple tool name like "Read"
+    z.object({
+        name: z.string(),
+        filter: z.string().optional(), // e.g., "git:*" for Bash(git:*)
+    }),
+]);
+/**
+ * Skill metadata from SKILL.md frontmatter.
+ * This is the lightweight representation loaded at startup (~100 tokens).
+ */
+export const SkillMetadataSchema = z.object({
+    /** Unique skill name (kebab-case) */
+    name: z.string().regex(/^[a-z0-9-]+$/, 'Skill name must be kebab-case'),
+    /** Human-readable description */
+    description: z.string(),
+    /** Version following semver */
+    version: z.string().optional(),
+    /** SPDX license identifier */
+    license: z.string().optional(),
+    /** Author or organization */
+    author: z.string().optional(),
+    /** Repository URL */
+    repository: z.string().url().optional(),
+    /** Skill tags for categorization */
+    tags: z.array(z.string()).optional(),
+    /** Compatible agent frameworks */
+    compatibility: z
+        .array(z.enum([
+        'claude-code',
+        'cursor',
+        'windsurf',
+        'cline',
+        'copilot',
+        'openai',
+        'anthropic',
+        'universal',
+    ]))
+        .optional(),
+    /** Allowed tools this skill can use */
+    allowedTools: z.array(z.string()).optional(),
+    /** Minimum required context window */
+    minContextWindow: z.number().int().positive().optional(),
+    /** Whether this skill requires human approval before actions */
+    requiresApproval: z.boolean().optional(),
+});
+/**
+ * Resource file within a skill package.
+ */
+export const SkillResourceSchema = z.object({
+    /** Relative path within skill directory */
+    path: z.string(),
+    /** File type */
+    type: z.enum(['script', 'reference', 'asset', 'template', 'schema']),
+    /** File content (loaded on demand) */
+    content: z.string().optional(),
+});
+/**
+ * Source of a skill - where it was loaded from.
+ */
+export const SkillSourceSchema = z.enum(['github', 'local', 'vercel']);
+/**
+ * Full skill object with instructions and resources.
+ */
+export const SkillSchema = z.object({
+    /** Skill metadata from frontmatter */
+    metadata: SkillMetadataSchema,
+    /** Markdown instructions for the agent */
+    instructions: z.string(),
+    /** Source path where skill is installed */
+    sourcePath: z.string(),
+    /** Whether this is a project-local or global skill */
+    scope: z.enum(['local', 'global']),
+    /** Source type - where this skill came from */
+    source: SkillSourceSchema.optional(),
+    /** Original source identifier (e.g., GitHub URL, Vercel package name) */
+    sourceIdentifier: z.string().optional(),
+    /** Optional resources (scripts, references, assets) */
+    resources: z.array(SkillResourceSchema).optional(),
+    /** Embedding vector for semantic search */
+    embedding: z.array(z.number()).optional(),
+    /** When the skill was installed */
+    installedAt: z.string().datetime().optional(),
+    /** When the skill was last updated */
+    updatedAt: z.string().datetime().optional(),
+});
+/**
+ * Skill activation context - information needed to determine which skills to activate.
+ */
+export const SkillActivationContextSchema = z.object({
+    /** Current task description or user message */
+    taskDescription: z.string().optional(),
+    /** Explicit skill names requested (e.g., /skill-name) */
+    explicitSkills: z.array(z.string()).optional(),
+    /** Current file context (for file-type based activation) */
+    currentFiles: z.array(z.string()).optional(),
+    /** Project type hints */
+    projectType: z.string().optional(),
+});
+/**
+ * Result of skill activation.
+ */
+export const SkillActivationResultSchema = z.object({
+    /** Skills that were activated */
+    activatedSkills: z.array(SkillSchema),
+    /** Reason each skill was activated */
+    activationReasons: z.record(z.string(), z.object({
+        type: z.enum(['explicit', 'semantic', 'file-match', 'project-type']),
+        score: z.number().optional(),
+        reason: z.string().optional(),
+    })),
+});
+/**
+ * Parse an allowed-tools string like "Bash(git:*)" into structured form.
+ */
+export function parseAllowedTool(spec) {
+    // Match patterns like "Bash(git:*)" or "Bash(npm install:*)" or simple "Read"
+    const match = spec.match(/^(\w+)(?:\(([^)]+)\))?$/);
+    if (!match) {
+        throw new Error(`Invalid allowed-tool specification: ${spec}`);
+    }
+    const [, matchedName, filterSpec] = match;
+    const name = matchedName;
+    if (!filterSpec) {
+        return { name };
+    }
+    // Determine filter type
+    let type = 'exact';
+    let pattern = filterSpec;
+    if (filterSpec.endsWith(':*')) {
+        type = 'prefix';
+        pattern = filterSpec.slice(0, -2);
+    }
+    else if (filterSpec.includes('*')) {
+        type = 'glob';
+    }
+    return {
+        name,
+        filter: { pattern, type },
+    };
+}
+/**
+ * Check if a command matches an allowed-tool filter.
+ */
+export function matchesAllowedTool(toolName, command, allowed) {
+    if (allowed.name !== toolName) {
+        return false;
+    }
+    if (!allowed.filter) {
+        return true;
+    }
+    switch (allowed.filter.type) {
+        case 'prefix':
+            return command.startsWith(allowed.filter.pattern);
+        case 'exact':
+            return command === allowed.filter.pattern;
+        case 'glob': {
+            // Simple glob matching - convert * to regex
+            const regex = new RegExp(`^${allowed.filter.pattern.replace(/\*/g, '.*').replace(/\?/g, '.')}$`);
+            return regex.test(command);
+        }
+        default:
+            return false;
+    }
+}

package/dist/templates/agent-spec.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Agent Specification Template
+ *
+ * Zod-validated schema that every agent MUST satisfy before registration.
+ * Encodes security constraints, permission boundaries, guardrails, and
+ * quality requirements directly into the type system. Nothing can be
+ * registered without passing validation.
+ */
+import { z } from 'zod';
+export declare const AgentPermissionsSchema: z.ZodObject<{
+    allowedTools: z.ZodArray<z.ZodString>;
+    deniedTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    maxToolCallsPerTask: z.ZodDefault<z.ZodNumber>;
+    maxLLMCallsPerTask: z.ZodDefault<z.ZodNumber>;
+    canDelegateToAgents: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    canAccessMemoryTypes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        semantic: "semantic";
+        working: "working";
+        episodic: "episodic";
+    }>>>;
+    maxMemoryWritesPerTask: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type AgentPermissions = z.infer<typeof AgentPermissionsSchema>;
+export declare const AgentSecuritySchema: z.ZodObject<{
+    requiresHumanApproval: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    sensitiveDataHandling: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        read_only: "read_only";
+        full_access: "full_access";
+    }>>;
+    allowNetworkAccess: z.ZodDefault<z.ZodBoolean>;
+    allowFileSystemAccess: z.ZodDefault<z.ZodBoolean>;
+    sandboxed: z.ZodDefault<z.ZodBoolean>;
+    maxOutputBytes: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type AgentSecurity = z.infer<typeof AgentSecuritySchema>;
+export declare const AgentGuardrailsSchema: z.ZodObject<{
+    maxResponseTokens: z.ZodDefault<z.ZodNumber>;
+    prohibitedPatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    requiredOutputFormat: z.ZodOptional<z.ZodEnum<{
+        text: "text";
+        json: "json";
+        structured: "structured";
+    }>>;
+    mustCiteSource: z.ZodDefault<z.ZodBoolean>;
+    allowSelfModification: z.ZodDefault<z.ZodBoolean>;
+    maxExecutionTimeMs: z.ZodDefault<z.ZodNumber>;
+    maxIterations: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type AgentGuardrails = z.infer<typeof AgentGuardrailsSchema>;
+export declare const AgentQualitySchema: z.ZodObject<{
+    minTestCoverage: z.ZodOptional<z.ZodNumber>;
+    requiredReviewers: z.ZodDefault<z.ZodNumber>;
+    changelogRequired: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type AgentQuality = z.infer<typeof AgentQualitySchema>;
+export declare const AgentSpecSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodString;
+    instructions: z.ZodString;
+    permissions: z.ZodObject<{
+        allowedTools: z.ZodArray<z.ZodString>;
+        deniedTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        maxToolCallsPerTask: z.ZodDefault<z.ZodNumber>;
+        maxLLMCallsPerTask: z.ZodDefault<z.ZodNumber>;
+        canDelegateToAgents: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        canAccessMemoryTypes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            semantic: "semantic";
+            working: "working";
+            episodic: "episodic";
+        }>>>;
+        maxMemoryWritesPerTask: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    security: z.ZodObject<{
+        requiresHumanApproval: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        sensitiveDataHandling: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            read_only: "read_only";
+            full_access: "full_access";
+        }>>;
+        allowNetworkAccess: z.ZodDefault<z.ZodBoolean>;
+        allowFileSystemAccess: z.ZodDefault<z.ZodBoolean>;
+        sandboxed: z.ZodDefault<z.ZodBoolean>;
+        maxOutputBytes: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    guardrails: z.ZodObject<{
+        maxResponseTokens: z.ZodDefault<z.ZodNumber>;
+        prohibitedPatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        requiredOutputFormat: z.ZodOptional<z.ZodEnum<{
+            text: "text";
+            json: "json";
+            structured: "structured";
+        }>>;
+        mustCiteSource: z.ZodDefault<z.ZodBoolean>;
+        allowSelfModification: z.ZodDefault<z.ZodBoolean>;
+        maxExecutionTimeMs: z.ZodDefault<z.ZodNumber>;
+        maxIterations: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    quality: z.ZodObject<{
+        minTestCoverage: z.ZodOptional<z.ZodNumber>;
+        requiredReviewers: z.ZodDefault<z.ZodNumber>;
+        changelogRequired: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+    owner: z.ZodString;
+    tier: z.ZodDefault<z.ZodEnum<{
+        free: "free";
+        pro: "pro";
+        enterprise: "enterprise";
+    }>>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>;
+export type AgentSpec = z.infer<typeof AgentSpecSchema>;
+/**
+ * Validate an agent specification.
+ * Returns the validated spec or throws with detailed error messages.
+ */
+export declare function validateAgentSpec(input: unknown): AgentSpec;
+/**
+ * Safely validate an agent specification.
+ * Returns a result object with either the data or validation errors.
+ */
+export declare function safeValidateAgentSpec(input: unknown): {
+    success: true;
+    data: AgentSpec;
+} | {
+    success: false;
+    errors: string[];
+};
+/**
+ * Create a minimal agent spec with sensible defaults.
+ * Fills in security, permissions, guardrails, and quality with safe defaults.
+ */
+export declare function createAgentSpec(partial: Pick<AgentSpec, 'id' | 'name' | 'version' | 'description' | 'instructions' | 'owner'> & Partial<AgentSpec>): AgentSpec;
+//# sourceMappingURL=agent-spec.d.ts.map

package/dist/templates/agent-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-spec.d.ts","sourceRoot":"","sources":["../../src/templates/agent-spec.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;iBAejC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAIrE,eAAO,MAAM,mBAAmB;;;;;;;;;;;iBAa9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAI/D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;iBAehC,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAInE,eAAO,MAAM,kBAAkB;;;;iBAO7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAI7D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6B1B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAIvD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,CAE3D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,GACb;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAS3E;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,GAAG,aAAa,GAAG,cAAc,GAAG,OAAO,CAAC,GAC5F,OAAO,CAAC,SAAS,CAAC,GACnB,SAAS,CAaX"}

package/dist/templates/agent-spec.js

@@ -0,0 +1,138 @@
+/**
+ * Agent Specification Template
+ *
+ * Zod-validated schema that every agent MUST satisfy before registration.
+ * Encodes security constraints, permission boundaries, guardrails, and
+ * quality requirements directly into the type system. Nothing can be
+ * registered without passing validation.
+ */
+import { z } from 'zod';
+// ─── Permission Schema ──────────────────────────────────────────────────────
+export const AgentPermissionsSchema = z.object({
+    /** Explicit whitelist of tool names this agent can use */
+    allowedTools: z.array(z.string().min(1)),
+    /** Explicit blacklist of tool names (overrides allowedTools) */
+    deniedTools: z.array(z.string()).default([]),
+    /** Maximum tool calls per single task execution */
+    maxToolCallsPerTask: z.number().int().positive().default(50),
+    /** Maximum LLM API calls per single task execution */
+    maxLLMCallsPerTask: z.number().int().positive().default(20),
+    /** Agent IDs this agent is allowed to delegate tasks to */
+    canDelegateToAgents: z.array(z.string()).default([]),
+    /** Memory types this agent can access */
+    canAccessMemoryTypes: z.array(z.enum(['working', 'episodic', 'semantic'])).default([]),
+    /** Maximum memory write operations per task */
+    maxMemoryWritesPerTask: z.number().int().positive().default(100),
+});
+// ─── Security Schema ────────────────────────────────────────────────────────
+export const AgentSecuritySchema = z.object({
+    /** Actions that require explicit human approval before execution */
+    requiresHumanApproval: z.array(z.string()).default([]),
+    /** How this agent handles sensitive data */
+    sensitiveDataHandling: z.enum(['none', 'read_only', 'full_access']).default('none'),
+    /** Whether the agent can make external network requests */
+    allowNetworkAccess: z.boolean().default(false),
+    /** Whether the agent can read/write to the filesystem */
+    allowFileSystemAccess: z.boolean().default(false),
+    /** Whether the agent runs in a sandboxed environment */
+    sandboxed: z.boolean().default(true),
+    /** Maximum data the agent can exfiltrate per task (bytes, 0 = no limit) */
+    maxOutputBytes: z.number().int().min(0).default(0),
+});
+// ─── Guardrails Schema ──────────────────────────────────────────────────────
+export const AgentGuardrailsSchema = z.object({
+    /** Maximum tokens in any single LLM response */
+    maxResponseTokens: z.number().int().positive().default(4096),
+    /** Regex patterns that MUST NOT appear in agent output */
+    prohibitedPatterns: z.array(z.string()).default([]),
+    /** Required output format (if any) */
+    requiredOutputFormat: z.enum(['text', 'json', 'structured']).optional(),
+    /** Whether agent outputs must cite their data source */
+    mustCiteSource: z.boolean().default(false),
+    /** Whether the agent can modify its own specification (should almost always be false) */
+    allowSelfModification: z.boolean().default(false),
+    /** Maximum task execution time in milliseconds */
+    maxExecutionTimeMs: z.number().int().positive().default(120_000),
+    /** Maximum number of agentic loop iterations per task */
+    maxIterations: z.number().int().positive().default(10),
+});
+// ─── Quality Schema ─────────────────────────────────────────────────────────
+export const AgentQualitySchema = z.object({
+    /** Minimum test coverage percentage required for this agent's code */
+    minTestCoverage: z.number().min(0).max(100).optional(),
+    /** Number of human reviewers required before changes to this spec */
+    requiredReviewers: z.number().int().min(0).default(0),
+    /** Whether changes to this spec require a changelog entry */
+    changelogRequired: z.boolean().default(false),
+});
+// ─── Full Agent Specification ───────────────────────────────────────────────
+export const AgentSpecSchema = z.object({
+    /** Unique agent identifier */
+    id: z.string().min(1).max(100),
+    /** Human-readable agent name */
+    name: z.string().min(1).max(100),
+    /** Semantic version */
+    version: z.string().regex(/^\d+\.\d+\.\d+$/, 'Must be semver (e.g., 1.0.0)'),
+    /** What this agent does */
+    description: z.string().min(10).max(1000),
+    /** System prompt / instructions for the agent */
+    instructions: z.string().min(20),
+    /** Permission boundaries */
+    permissions: AgentPermissionsSchema,
+    /** Security constraints */
+    security: AgentSecuritySchema,
+    /** Behavioral guardrails */
+    guardrails: AgentGuardrailsSchema,
+    /** Quality requirements */
+    quality: AgentQualitySchema,
+    /** Who owns this agent spec */
+    owner: z.string().min(1),
+    /** License tier required */
+    tier: z.enum(['free', 'pro', 'enterprise']).default('pro'),
+    /** Tags for categorization */
+    tags: z.array(z.string()).default([]),
+    /** When this spec was created */
+    createdAt: z.date(),
+    /** When this spec was last updated */
+    updatedAt: z.date(),
+});
+// ─── Validation ─────────────────────────────────────────────────────────────
+/**
+ * Validate an agent specification.
+ * Returns the validated spec or throws with detailed error messages.
+ */
+export function validateAgentSpec(input) {
+    return AgentSpecSchema.parse(input);
+}
+/**
+ * Safely validate an agent specification.
+ * Returns a result object with either the data or validation errors.
+ */
+export function safeValidateAgentSpec(input) {
+    const result = AgentSpecSchema.safeParse(input);
+    if (result.success) {
+        return { success: true, data: result.data };
+    }
+    return {
+        success: false,
+        errors: result.error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`),
+    };
+}
+/**
+ * Create a minimal agent spec with sensible defaults.
+ * Fills in security, permissions, guardrails, and quality with safe defaults.
+ */
+export function createAgentSpec(partial) {
+    const now = new Date();
+    return AgentSpecSchema.parse({
+        permissions: {},
+        security: {},
+        guardrails: {},
+        quality: {},
+        tags: [],
+        tier: 'pro',
+        createdAt: now,
+        updatedAt: now,
+        ...partial,
+    });
+}

package/dist/templates/index.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Agent, Skill, and Prompt Specification Templates
+ *
+ * Zod-validated schemas that enforce guardrails, security, and quality
+ * at registration time. Nothing can be registered in the system without
+ * passing these validations.
+ *
+ * ## Quick Start
+ *
+ * ```typescript
+ * import {
+ *   createAgentSpec,
+ *   createSkillSpec,
+ *   createPromptSpec,
+ *   renderPromptTemplate,
+ * } from '@revealui/ai'
+ *
+ * // Create an agent spec (enforces permissions, security, guardrails)
+ * const agentSpec = createAgentSpec({
+ *   id: 'email-agent',
+ *   name: 'Email Management Agent',
+ *   version: '1.0.0',
+ *   description: 'Manages email triage, drafting, and scheduling',
+ *   instructions: 'You are an email management assistant...',
+ *   owner: 'admin',
+ *   permissions: {
+ *     allowedTools: ['read_email', 'draft_email', 'send_email'],
+ *     deniedTools: ['delete_email'],
+ *     maxToolCallsPerTask: 20,
+ *   },
+ *   security: {
+ *     sensitiveDataHandling: 'read_only',
+ *     allowNetworkAccess: true,
+ *   },
+ * })
+ *
+ * // Create a skill spec (requires test cases)
+ * const skillSpec = createSkillSpec({
+ *   id: 'email-summarize',
+ *   name: 'Email Summarizer',
+ *   version: '1.0.0',
+ *   description: 'Summarizes an email thread into key points',
+ *   author: 'admin',
+ *   category: 'email',
+ *   inputSchema: { thread: { type: 'string' } },
+ *   outputSchema: { summary: { type: 'string' }, keyPoints: { type: 'array' } },
+ *   testCases: [
+ *     { description: 'Basic thread', input: { thread: '...' }, shouldPass: true },
+ *   ],
+ * })
+ * ```
+ */
+export { type AgentGuardrails, AgentGuardrailsSchema, type AgentPermissions, AgentPermissionsSchema, type AgentQuality, AgentQualitySchema, type AgentSecurity, AgentSecuritySchema, type AgentSpec, AgentSpecSchema, createAgentSpec, safeValidateAgentSpec, validateAgentSpec, } from './agent-spec.js';
+export { createPromptSpec, type PromptExample, PromptExampleSchema, type PromptGuardrails, PromptGuardrailsSchema, type PromptSecurity, PromptSecuritySchema, type PromptSpec, PromptSpecSchema, type PromptVariable, PromptVariableSchema, renderPromptTemplate, safeValidatePromptSpec, validatePromptSpec, } from './prompt-spec.js';
+export { createSkillSpec, type SkillPermissions, SkillPermissionsSchema, type SkillSecurity, SkillSecuritySchema, type SkillSpec, SkillSpecSchema, type SkillTestCase, SkillTestCaseSchema, safeValidateSkillSpec, validateSkillSpec, } from './skill-spec.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/templates/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/templates/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAGH,OAAO,EACL,KAAK,eAAe,EACpB,qBAAqB,EACrB,KAAK,gBAAgB,EACrB,sBAAsB,EACtB,KAAK,YAAY,EACjB,kBAAkB,EAClB,KAAK,aAAa,EAClB,mBAAmB,EACnB,KAAK,SAAS,EACd,eAAe,EACf,eAAe,EACf,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,iBAAiB,CAAA;AAExB,OAAO,EACL,gBAAgB,EAChB,KAAK,aAAa,EAClB,mBAAmB,EACnB,KAAK,gBAAgB,EACrB,sBAAsB,EACtB,KAAK,cAAc,EACnB,oBAAoB,EACpB,KAAK,UAAU,EACf,gBAAgB,EAChB,KAAK,cAAc,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,kBAAkB,GACnB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EACL,eAAe,EACf,KAAK,gBAAgB,EACrB,sBAAsB,EACtB,KAAK,aAAa,EAClB,mBAAmB,EACnB,KAAK,SAAS,EACd,eAAe,EACf,KAAK,aAAa,EAClB,mBAAmB,EACnB,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,iBAAiB,CAAA"}

package/dist/templates/index.js

@@ -0,0 +1,58 @@
+/**
+ * Agent, Skill, and Prompt Specification Templates
+ *
+ * Zod-validated schemas that enforce guardrails, security, and quality
+ * at registration time. Nothing can be registered in the system without
+ * passing these validations.
+ *
+ * ## Quick Start
+ *
+ * ```typescript
+ * import {
+ *   createAgentSpec,
+ *   createSkillSpec,
+ *   createPromptSpec,
+ *   renderPromptTemplate,
+ * } from '@revealui/ai'
+ *
+ * // Create an agent spec (enforces permissions, security, guardrails)
+ * const agentSpec = createAgentSpec({
+ *   id: 'email-agent',
+ *   name: 'Email Management Agent',
+ *   version: '1.0.0',
+ *   description: 'Manages email triage, drafting, and scheduling',
+ *   instructions: 'You are an email management assistant...',
+ *   owner: 'admin',
+ *   permissions: {
+ *     allowedTools: ['read_email', 'draft_email', 'send_email'],
+ *     deniedTools: ['delete_email'],
+ *     maxToolCallsPerTask: 20,
+ *   },
+ *   security: {
+ *     sensitiveDataHandling: 'read_only',
+ *     allowNetworkAccess: true,
+ *   },
+ * })
+ *
+ * // Create a skill spec (requires test cases)
+ * const skillSpec = createSkillSpec({
+ *   id: 'email-summarize',
+ *   name: 'Email Summarizer',
+ *   version: '1.0.0',
+ *   description: 'Summarizes an email thread into key points',
+ *   author: 'admin',
+ *   category: 'email',
+ *   inputSchema: { thread: { type: 'string' } },
+ *   outputSchema: { summary: { type: 'string' }, keyPoints: { type: 'array' } },
+ *   testCases: [
+ *     { description: 'Basic thread', input: { thread: '...' }, shouldPass: true },
+ *   ],
+ * })
+ * ```
+ */
+// Agent specification
+export { AgentGuardrailsSchema, AgentPermissionsSchema, AgentQualitySchema, AgentSecuritySchema, AgentSpecSchema, createAgentSpec, safeValidateAgentSpec, validateAgentSpec, } from './agent-spec.js';
+// Prompt specification
+export { createPromptSpec, PromptExampleSchema, PromptGuardrailsSchema, PromptSecuritySchema, PromptSpecSchema, PromptVariableSchema, renderPromptTemplate, safeValidatePromptSpec, validatePromptSpec, } from './prompt-spec.js';
+// Skill specification
+export { createSkillSpec, SkillPermissionsSchema, SkillSecuritySchema, SkillSpecSchema, SkillTestCaseSchema, safeValidateSkillSpec, validateSkillSpec, } from './skill-spec.js';