@objectstack/spec 0.9.0 → 0.9.2

package/README.md

@@ -14,6 +14,20 @@ This package defines the **DNA** of ObjectStack. It contains:
 
 **Guiding Principle:** *"Strict Types, No Logic"*
 
+## 🤖 AI Development Context
+
+**Role**: Protocol Definition (Source of Truth)
+**Usage**: 
+- Import Zod schemas from here for validation.
+- Import Types from here for type safety.
+- DO NOT implement business logic here.
+- DO NOT duplicate schemas in other packages; import from here.
+
+**Key Exports**:
+- `Data.ObjectSchema` -> The definition of a Business Object.
+- `Data.FieldSchema` -> Sub-schema for fields.
+- `UI.ViewSchema` -> Definition of UI Views.
+
 ## 🚀 Installation
 
 ```bash
@@ -54,20 +68,74 @@ The specification is organized into five namespaces mapping to the three-layer a
 
 ## 📚 Usage
 
+### 🤖 AI Quick Reference
+
+**For AI Agents and LLMs:** This package is the single source of truth for ObjectStack protocol definitions. When working with ObjectStack:
+
+1. **Import Patterns**: Always use namespace imports (`Data.Field`, `UI.View`) or direct subpath imports
+2. **Validation**: Use Zod schemas for runtime validation (e.g., `ObjectSchema.parse(config)`)
+3. **Type Inference**: Derive TypeScript types from Zod (`type Field = z.infer<typeof FieldSchema>`)
+4. **Naming Convention**: 
+   - Configuration keys (TypeScript properties): `camelCase` (e.g., `maxLength`, `defaultValue`)
+   - Machine names (data values): `snake_case` (e.g., `name: 'todo_task'`, `field: 'due_date'`)
+5. **Context Files**: Load prompts from `prompts/` directory for architectural understanding
+
+**Common Tasks:**
+```typescript
+// Define an Object
+import { Data } from '@objectstack/spec';
+const task: Data.Object = {
+  name: 'todo_task',
+  fields: {
+    subject: { type: 'text', label: 'Subject', required: true },
+    priority: { type: 'number', min: 1, max: 5 }
+  }
+};
+
+// Validate at runtime
+import { ObjectSchema } from '@objectstack/spec/data';
+const result = ObjectSchema.safeParse(task);
+
+// Define an App
+import { UI } from '@objectstack/spec';
+const app: UI.App = {
+  id: 'crm',
+  name: 'CRM',
+  navigation: { /* ... */ }
+};
+```
+
 ### Import Styles
 
 **Important:** This package does NOT export types at the root level to prevent naming conflicts. You must use one of the following import styles:
 
 ### 🤖 AI-Ready Context
 
-This package includes a `prompts/` directory containing system instructions and architectural context. This is useful for:
+This package includes a `prompts/` directory in the package root containing system instructions and architectural context:
+
+```
+node_modules/@objectstack/spec/prompts/
+├── architecture.md    # System architecture overview
+├── plugin/           # Plugin development guides
+└── development/      # Development workflows
+```
+
+These prompts are useful for:
 1.  **AI Agents**: Creating agents that understand ObjectStack.
 2.  **IDE Context**: Adding `node_modules/@objectstack/spec/prompts/*.md` to your Cursor/Copilot context.
-3.  **LLM Auto-Discovery**: The `llms.txt` file in the root provides a knowledge base for autonomous agents.
+3.  **LLM Auto-Discovery**: The `llms.txt` file in the repository root provides a knowledge base for autonomous agents.
 
 ```typescript
-import context from '@objectstack/spec/prompts/architecture.md?raw'; // If using Vite/bundler
-// Or just read the file from disk
+// If using Vite/bundler with raw import support
+import context from '@objectstack/spec/prompts/architecture.md?raw';
+
+// Or read from disk in Node.js
+import fs from 'fs';
+import path from 'path';
+const context = fs.readFileSync(
+  path.join(process.cwd(), 'node_modules/@objectstack/spec/prompts/architecture.md'),
+  'utf-8'
+);
 ```
 
 #### 1. Namespace Imports from Root

package/dist/ai/cost.zod.d.ts

@@ -852,8 +852,8 @@ export declare const CostQueryFiltersSchema: z.ZodObject<{
     }>>>;
     orderBy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         timestamp: "timestamp";
-        tokens: "tokens";
         cost: "cost";
+        tokens: "tokens";
     }>>>;
     orderDirection: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         asc: "asc";

package/dist/ai/devops-agent.zod.d.ts

@@ -61,8 +61,8 @@ export declare const CodeGenerationTargetSchema: z.ZodEnum<{
     database: "database";
     api: "api";
     documentation: "documentation";
-    frontend: "frontend";
     backend: "backend";
+    frontend: "frontend";
     tests: "tests";
     infrastructure: "infrastructure";
 }>;
@@ -76,8 +76,8 @@ export declare const CodeGenerationConfigSchema: z.ZodObject<{
         database: "database";
         api: "api";
         documentation: "documentation";
-        frontend: "frontend";
         backend: "backend";
+        frontend: "frontend";
         tests: "tests";
         infrastructure: "infrastructure";
     }>>;
@@ -204,8 +204,8 @@ export type VersionManagement = z.infer<typeof VersionManagementSchema>;
 export declare const DeploymentStrategySchema: z.ZodObject<{
     type: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         rolling: "rolling";
-        blue_green: "blue_green";
         canary: "canary";
+        blue_green: "blue_green";
         recreate: "recreate";
     }>>>;
     canaryPercentage: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
@@ -251,8 +251,8 @@ export declare const DevelopmentConfigSchema: z.ZodObject<{
             database: "database";
             api: "api";
             documentation: "documentation";
-            frontend: "frontend";
             backend: "backend";
+            frontend: "frontend";
             tests: "tests";
             infrastructure: "infrastructure";
         }>>;
@@ -408,8 +408,8 @@ export declare const DevOpsAgentSchema: z.ZodObject<{
                 database: "database";
                 api: "api";
                 documentation: "documentation";
-                frontend: "frontend";
                 backend: "backend";
+                frontend: "frontend";
                 tests: "tests";
                 infrastructure: "infrastructure";
             }>>;
@@ -508,8 +508,8 @@ export declare const DevOpsAgentSchema: z.ZodObject<{
     deploymentStrategy: z.ZodOptional<z.ZodObject<{
         type: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
             rolling: "rolling";
-            blue_green: "blue_green";
             canary: "canary";
+            blue_green: "blue_green";
             recreate: "recreate";
         }>>>;
         canaryPercentage: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;

package/dist/ai/index.d.ts

@@ -11,10 +11,14 @@
  * - Predictive Analytics
  * - Conversation Memory & Token Management
  * - Cost Tracking & Budget Management
+ * - Plugin Development (AI-assisted)
+ * - Runtime Operations (AIOps)
  */
 export * from './agent.zod';
 export * from './agent-action.zod';
 export * from './devops-agent.zod';
+export * from './plugin-development.zod';
+export * from './runtime-ops.zod';
 export * from './model-registry.zod';
 export * from './rag-pipeline.zod';
 export * from './nlq.zod';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ai/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ai/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC"}

package/dist/ai/index.js

@@ -12,6 +12,8 @@
  * - Predictive Analytics
  * - Conversation Memory & Token Management
  * - Cost Tracking & Budget Management
+ * - Plugin Development (AI-assisted)
+ * - Runtime Operations (AIOps)
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -31,6 +33,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./agent.zod"), exports);
 __exportStar(require("./agent-action.zod"), exports);
 __exportStar(require("./devops-agent.zod"), exports);
+__exportStar(require("./plugin-development.zod"), exports);
+__exportStar(require("./runtime-ops.zod"), exports);
 __exportStar(require("./model-registry.zod"), exports);
 __exportStar(require("./rag-pipeline.zod"), exports);
 __exportStar(require("./nlq.zod"), exports);

package/dist/ai/plugin-development.zod.d.ts

@@ -0,0 +1,415 @@
+import { z } from 'zod';
+/**
+ * # AI-Driven Plugin Development Protocol
+ *
+ * Defines protocols for AI-powered plugin development including:
+ * - Natural language to code generation
+ * - Intelligent code scaffolding
+ * - Automated testing and validation
+ * - AI-powered code review and optimization
+ * - Plugin composition and recommendation
+ */
+/**
+ * Code Generation Request
+ * Request for AI to generate plugin code
+ */
+export declare const CodeGenerationRequestSchema: z.ZodObject<{
+    description: z.ZodString;
+    pluginType: z.ZodEnum<{
+        custom: "custom";
+        widget: "widget";
+        app: "app";
+        integration: "integration";
+        driver: "driver";
+        analytics: "analytics";
+        automation: "automation";
+        "ai-agent": "ai-agent";
+    }>;
+    outputFormat: z.ZodDefault<z.ZodEnum<{
+        "source-code": "source-code";
+        "low-code-schema": "low-code-schema";
+        dsl: "dsl";
+    }>>;
+    language: z.ZodDefault<z.ZodEnum<{
+        javascript: "javascript";
+        typescript: "typescript";
+        python: "python";
+    }>>;
+    framework: z.ZodOptional<z.ZodObject<{
+        runtime: z.ZodOptional<z.ZodEnum<{
+            browser: "browser";
+            edge: "edge";
+            node: "node";
+            universal: "universal";
+        }>>;
+        uiFramework: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            react: "react";
+            vue: "vue";
+            svelte: "svelte";
+        }>>;
+        testing: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            vitest: "vitest";
+            jest: "jest";
+            mocha: "mocha";
+        }>>;
+    }, z.core.$strip>>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    examples: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        input: z.ZodString;
+        expectedOutput: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    style: z.ZodOptional<z.ZodObject<{
+        indentation: z.ZodDefault<z.ZodEnum<{
+            tab: "tab";
+            "2spaces": "2spaces";
+            "4spaces": "4spaces";
+        }>>;
+        quotes: z.ZodDefault<z.ZodEnum<{
+            single: "single";
+            double: "double";
+        }>>;
+        semicolons: z.ZodDefault<z.ZodBoolean>;
+        trailingComma: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    schemaOptions: z.ZodOptional<z.ZodObject<{
+        format: z.ZodDefault<z.ZodEnum<{
+            json: "json";
+            yaml: "yaml";
+            typescript: "typescript";
+        }>>;
+        includeExamples: z.ZodDefault<z.ZodBoolean>;
+        strictValidation: z.ZodDefault<z.ZodBoolean>;
+        generateUI: z.ZodDefault<z.ZodBoolean>;
+        generateDataModels: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    context: z.ZodOptional<z.ZodObject<{
+        existingCode: z.ZodOptional<z.ZodString>;
+        documentationUrls: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        referencePlugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    options: z.ZodOptional<z.ZodObject<{
+        generateTests: z.ZodDefault<z.ZodBoolean>;
+        generateDocs: z.ZodDefault<z.ZodBoolean>;
+        generateExamples: z.ZodDefault<z.ZodBoolean>;
+        targetCoverage: z.ZodDefault<z.ZodNumber>;
+        optimizationLevel: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            basic: "basic";
+            aggressive: "aggressive";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Generated Code
+ * Result of code generation
+ */
+export declare const GeneratedCodeSchema: z.ZodObject<{
+    outputFormat: z.ZodEnum<{
+        "source-code": "source-code";
+        "low-code-schema": "low-code-schema";
+        dsl: "dsl";
+    }>;
+    code: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodString>;
+    schemas: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            object: "object";
+            dashboard: "dashboard";
+            page: "page";
+            api: "api";
+            app: "app";
+            view: "view";
+            workflow: "workflow";
+        }>;
+        path: z.ZodString;
+        content: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+        coverage: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    documentation: z.ZodOptional<z.ZodObject<{
+        readme: z.ZodOptional<z.ZodString>;
+        api: z.ZodOptional<z.ZodString>;
+        usage: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    package: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>;
+    quality: z.ZodOptional<z.ZodObject<{
+        complexity: z.ZodOptional<z.ZodNumber>;
+        maintainability: z.ZodOptional<z.ZodNumber>;
+        testCoverage: z.ZodOptional<z.ZodNumber>;
+        lintScore: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    confidence: z.ZodNumber;
+    suggestions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Plugin Scaffolding Template
+ * Template for plugin structure
+ */
+export declare const PluginScaffoldingTemplateSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    pluginType: z.ZodString;
+    structure: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            file: "file";
+            directory: "directory";
+        }>;
+        path: z.ZodString;
+        template: z.ZodOptional<z.ZodString>;
+        optional: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    variables: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            array: "array";
+        }>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodAny>;
+        validation: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    scripts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        command: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        optional: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * AI Code Review Result
+ * Result of AI-powered code review
+ */
+export declare const AICodeReviewResultSchema: z.ZodObject<{
+    assessment: z.ZodEnum<{
+        excellent: "excellent";
+        good: "good";
+        acceptable: "acceptable";
+        "needs-improvement": "needs-improvement";
+        poor: "poor";
+    }>;
+    score: z.ZodNumber;
+    issues: z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<{
+            error: "error";
+            warning: "warning";
+            info: "info";
+            critical: "critical";
+            style: "style";
+        }>;
+        category: z.ZodEnum<{
+            documentation: "documentation";
+            style: "style";
+            performance: "performance";
+            testing: "testing";
+            security: "security";
+            maintainability: "maintainability";
+            bug: "bug";
+            "type-safety": "type-safety";
+            "best-practice": "best-practice";
+        }>;
+        file: z.ZodString;
+        line: z.ZodOptional<z.ZodNumber>;
+        column: z.ZodOptional<z.ZodNumber>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+        autoFixable: z.ZodDefault<z.ZodBoolean>;
+        autoFix: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    highlights: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        description: z.ZodString;
+        file: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    metrics: z.ZodOptional<z.ZodObject<{
+        complexity: z.ZodOptional<z.ZodNumber>;
+        maintainability: z.ZodOptional<z.ZodNumber>;
+        testCoverage: z.ZodOptional<z.ZodNumber>;
+        duplicateCode: z.ZodOptional<z.ZodNumber>;
+        technicalDebt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    recommendations: z.ZodArray<z.ZodObject<{
+        priority: z.ZodEnum<{
+            medium: "medium";
+            high: "high";
+            low: "low";
+        }>;
+        title: z.ZodString;
+        description: z.ZodString;
+        effort: z.ZodOptional<z.ZodEnum<{
+            small: "small";
+            medium: "medium";
+            large: "large";
+            trivial: "trivial";
+        }>>;
+    }, z.core.$strip>>;
+    security: z.ZodOptional<z.ZodObject<{
+        vulnerabilities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            severity: z.ZodEnum<{
+                medium: "medium";
+                critical: "critical";
+                high: "high";
+                low: "low";
+            }>;
+            type: z.ZodString;
+            description: z.ZodString;
+            remediation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        score: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Plugin Composition Request
+ * Request for AI to compose multiple plugins together
+ */
+export declare const PluginCompositionRequestSchema: z.ZodObject<{
+    goal: z.ZodString;
+    availablePlugins: z.ZodArray<z.ZodObject<{
+        pluginId: z.ZodString;
+        version: z.ZodString;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    constraints: z.ZodOptional<z.ZodObject<{
+        maxPlugins: z.ZodOptional<z.ZodNumber>;
+        requiredPlugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        excludedPlugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        performance: z.ZodOptional<z.ZodObject<{
+            maxLatency: z.ZodOptional<z.ZodNumber>;
+            maxMemory: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    optimize: z.ZodOptional<z.ZodEnum<{
+        performance: "performance";
+        security: "security";
+        reliability: "reliability";
+        simplicity: "simplicity";
+        cost: "cost";
+    }>>;
+}, z.core.$strip>;
+/**
+ * Plugin Composition Result
+ * AI-generated plugin composition
+ */
+export declare const PluginCompositionResultSchema: z.ZodObject<{
+    plugins: z.ZodArray<z.ZodObject<{
+        pluginId: z.ZodString;
+        version: z.ZodString;
+        role: z.ZodString;
+        configuration: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>>;
+    integration: z.ZodObject<{
+        code: z.ZodString;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        initOrder: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    dataFlow: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        data: z.ZodString;
+    }, z.core.$strip>>;
+    performance: z.ZodOptional<z.ZodObject<{
+        estimatedLatency: z.ZodOptional<z.ZodNumber>;
+        estimatedMemory: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    confidence: z.ZodNumber;
+    alternatives: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        plugins: z.ZodArray<z.ZodString>;
+        tradeoffs: z.ZodString;
+    }, z.core.$strip>>>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Plugin Recommendation Request
+ * Request for plugin recommendations
+ */
+export declare const PluginRecommendationRequestSchema: z.ZodObject<{
+    context: z.ZodObject<{
+        installedPlugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        industry: z.ZodOptional<z.ZodString>;
+        useCases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        teamSize: z.ZodOptional<z.ZodNumber>;
+        budget: z.ZodOptional<z.ZodEnum<{
+            medium: "medium";
+            high: "high";
+            low: "low";
+            free: "free";
+            unlimited: "unlimited";
+        }>>;
+    }, z.core.$strip>;
+    criteria: z.ZodOptional<z.ZodObject<{
+        prioritize: z.ZodOptional<z.ZodEnum<{
+            rating: "rating";
+            features: "features";
+            compatibility: "compatibility";
+            support: "support";
+            popularity: "popularity";
+            cost: "cost";
+        }>>;
+        certifiedOnly: z.ZodDefault<z.ZodBoolean>;
+        minRating: z.ZodOptional<z.ZodNumber>;
+        maxResults: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Plugin Recommendation
+ * AI-generated plugin recommendation
+ */
+export declare const PluginRecommendationSchema: z.ZodObject<{
+    recommendations: z.ZodArray<z.ZodObject<{
+        pluginId: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        score: z.ZodNumber;
+        reasons: z.ZodArray<z.ZodString>;
+        benefits: z.ZodArray<z.ZodString>;
+        considerations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        alternatives: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        estimatedValue: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    combinations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        plugins: z.ZodArray<z.ZodString>;
+        description: z.ZodString;
+        synergies: z.ZodArray<z.ZodString>;
+        totalScore: z.ZodNumber;
+    }, z.core.$strip>>>;
+    learningPath: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        step: z.ZodNumber;
+        plugin: z.ZodString;
+        reason: z.ZodString;
+        resources: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type CodeGenerationRequest = z.infer<typeof CodeGenerationRequestSchema>;
+export type GeneratedCode = z.infer<typeof GeneratedCodeSchema>;
+export type PluginScaffoldingTemplate = z.infer<typeof PluginScaffoldingTemplateSchema>;
+export type AICodeReviewResult = z.infer<typeof AICodeReviewResultSchema>;
+export type PluginCompositionRequest = z.infer<typeof PluginCompositionRequestSchema>;
+export type PluginCompositionResult = z.infer<typeof PluginCompositionResultSchema>;
+export type PluginRecommendationRequest = z.infer<typeof PluginRecommendationRequestSchema>;
+export type PluginRecommendation = z.infer<typeof PluginRecommendationSchema>;
+//# sourceMappingURL=plugin-development.zod.d.ts.map

package/dist/ai/plugin-development.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-development.zod.d.ts","sourceRoot":"","sources":["../../src/ai/plugin-development.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;GASG;AAEH;;;GAGG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2JtC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwF9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoD1C,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8EnC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;iBAsDzC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkExC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8D5C,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;iBAmCrC,CAAC;AAGH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AACxF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AACtF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AACpF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAC5F,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}