@punica/editor 1.0.5 → 1.0.7

package/types/punica.module.test.d.ts

@@ -0,0 +1,562 @@
+declare module 'punica' {
+  /**
+   * Test Specification ID
+   * Format: namespace-prefixed, kebab-case (e.g., "test.ivy.node.http.fetch", "test.mcp.github.search")
+   */
+  export type TestSpecificationId = string;
+
+  /**
+   * Capability ID reference (from capability module)
+   */
+  export type CapabilityId = string;
+
+  /**
+   * JSON types for test definitions
+   */
+  export type JSONPrimitive = string | number | boolean | null;
+  export type JSONValue =
+    | JSONPrimitive
+    | JSONValue[]
+    | { [key: string]: JSONValue };
+  export interface JSONObject {
+    [key: string]: JSONValue;
+  }
+
+  /**
+   * -------------------------
+   * Test Specification System
+   * -------------------------
+   * Bağımsız test tanımlama sistemi (CapabilityDefinition'dan bağımsız)
+   */
+
+  /**
+   * Matcher types for property and output assertions
+   */
+  export type MatcherType =
+    | 'equals' // Deep equality
+    | 'contains' // String/array contains
+    | 'matches' // Regex pattern
+    | 'greaterThan' // Numeric comparison
+    | 'lessThan' // Numeric comparison
+    | 'between' // Range check
+    | 'isType' // Type check
+    | 'hasProperty' // Object property existence
+    | 'arrayLength' // Array length check
+    | 'custom'; // Custom matcher
+
+  export interface MatcherOptions {
+    tolerance?: number;
+    caseSensitive?: boolean;
+    ignoreKeys?: string[];
+    customFn?: string;
+    [key: string]: JSONValue | undefined;
+  }
+
+  export interface MatcherConfig {
+    type: MatcherType;
+    value?: JSONValue;
+    options?: MatcherOptions;
+  }
+
+  /**
+   * Test Environment Configuration
+   */
+  export interface TestEnvironment {
+    /**
+     * Random seed for determinism
+     */
+    seed?: number;
+    /**
+     * Environment variables
+     */
+    env?: Record<string, string>;
+    /**
+     * Timezone for date/time tests
+     */
+    timezone?: string;
+    /**
+     * Locale for i18n tests
+     */
+    locale?: string;
+    /**
+     * Force deterministic execution
+     */
+    deterministic?: boolean;
+  }
+
+  /**
+   * Performance Assertion
+   */
+  export interface PerformanceAssertion {
+    /**
+     * Maximum execution duration in milliseconds
+     */
+    maxDurationMs?: number;
+    /**
+     * Maximum memory usage in MB
+     */
+    maxMemoryMB?: number;
+    /**
+     * Maximum CPU usage percentage
+     */
+    maxCpuPercent?: number;
+  }
+
+  /**
+   * Side-effect Check
+   */
+  export interface SideEffectCheck {
+    files?: {
+      /**
+       * Files that should be created
+       */
+      created?: string[];
+      /**
+       * Files that should be modified
+       */
+      modified?: string[];
+      /**
+       * Files that should be deleted
+       */
+      deleted?: string[];
+      /**
+       * Files that should not change
+       */
+      unchanged?: string[];
+    };
+    network?: {
+      /**
+       * Expected number of network requests
+       */
+      requests?: number;
+      /**
+       * Allowed domains
+       */
+      domains?: string[];
+    };
+    state?: {
+      /**
+       * State keys that should be modified
+       */
+      modified?: string[];
+      /**
+       * State keys that should not change
+       */
+      unchanged?: string[];
+    };
+  }
+
+  /**
+   * Output Assertion
+   */
+  export interface OutputAssertion {
+    /**
+     * Dot-path to output property (e.g., "result.value")
+     */
+    path?: string;
+    /**
+     * Matcher configuration
+     */
+    matcher: MatcherConfig;
+    /**
+     * Optional description
+     */
+    description?: string;
+  }
+
+  /**
+   * Execution Output Assertions
+   */
+  export interface ExecutionOutputAssertions {
+    stdout?: {
+      /**
+       * String that stdout should contain
+       */
+      contains?: string;
+      /**
+       * Regex pattern that stdout should match
+       */
+      matches?: string;
+      /**
+       * Whether stdout should be empty
+       */
+      isEmpty?: boolean;
+    };
+    stderr?: {
+      /**
+       * String that stderr should contain
+       */
+      contains?: string;
+      /**
+       * Regex pattern that stderr should match
+       */
+      matches?: string;
+      /**
+       * Whether stderr should be empty
+       */
+      isEmpty?: boolean;
+    };
+    displayData?: {
+      /**
+       * MIME type to matcher mapping
+       */
+      [mimeType: string]: MatcherConfig;
+    };
+  }
+
+  /**
+   * Property Assertion with matcher
+   */
+  export interface PropertyAssertion {
+    /**
+     * Expected value
+     */
+    expected?: JSONValue;
+    /**
+     * Matcher configuration or string (for backward compatibility)
+     */
+    matcher?: MatcherConfig | string;
+  }
+
+  /**
+   * Test Assertions
+   */
+  export interface TestAssertions {
+    /**
+     * Schema validation assertion
+     */
+    schema?: boolean;
+
+    /**
+     * Property-based assertions with matchers
+     */
+    properties?: Record<string, PropertyAssertion>;
+
+    /**
+     * Error expectation
+     */
+    expectsError?: boolean;
+
+    /**
+     * Error pattern matching (regex)
+     */
+    errorPattern?: string;
+
+    /**
+     * Output assertions
+     */
+    outputs?: OutputAssertion[];
+
+    /**
+     * Execution outputs (stdout, stderr, display_data)
+     */
+    executionOutputs?: ExecutionOutputAssertions;
+
+    /**
+     * Performance assertions
+     */
+    performance?: PerformanceAssertion;
+
+    /**
+     * Side-effect checks
+     */
+    sideEffects?: SideEffectCheck;
+  }
+
+  /**
+   * Test Case
+   */
+  export interface TestCase {
+    /**
+     * Unique identifier for this test case
+     */
+    id: string;
+    /**
+     * Human-readable description
+     */
+    description: string;
+    /**
+     * Test input data
+     */
+    input: JSONValue | JSONObject | null;
+    /**
+     * Test assertions
+     */
+    assertions?: TestAssertions;
+    /**
+     * Whether this is a golden test case
+     */
+    golden?: boolean;
+
+    /**
+     * Environment override for this test case
+     */
+    environment?: TestEnvironment;
+
+    /**
+     * Skip this test case (boolean or skip reason string)
+     */
+    skip?: boolean | string;
+
+    /**
+     * Tags for filtering and categorization
+     */
+    tags?: string[];
+  }
+
+  /**
+   * Test Spec
+   */
+  export interface TestSpec {
+    /**
+     * Test tier (quality gate level)
+     */
+    tier: 'draft' | 'verified' | 'certified';
+    /**
+     * Test cases
+     */
+    cases?: TestCase[];
+    /**
+     * Required dependencies for test execution
+     */
+    requires?: string[];
+    /**
+     * Default timeout for test cases (ms)
+     */
+    timeoutMs?: number;
+    /**
+     * Default environment configuration
+     */
+    environment?: TestEnvironment;
+    /**
+     * Execution options
+     */
+    execution?: {
+      /**
+       * Run tests in parallel
+       */
+      parallel?: boolean;
+      /**
+       * Number of retries for flaky tests
+       */
+      retries?: number;
+      /**
+       * Setup script/code
+       */
+      setup?: string;
+      /**
+       * Teardown script/code
+       */
+      teardown?: string;
+    };
+  }
+
+  /**
+   * Test Metadata
+   */
+  export interface TestMetadata {
+    /**
+     * Test author
+     */
+    author?: string;
+    /**
+     * Creation timestamp
+     */
+    createdAt?: string;
+    /**
+     * Last update timestamp
+     */
+    updatedAt?: string;
+    /**
+     * Tags for categorization
+     */
+    tags?: string[];
+    /**
+     * Allow additional metadata
+     */
+    [key: string]: unknown;
+  }
+
+  /**
+   * Test Specification - Bağımsız type system
+   * CapabilityDefinition'dan bağımsız, kendi sürecine sahip
+   */
+  export interface TestSpecification {
+    /**
+     * Unique identifier for this test specification
+     * Format: "test.{targetCapabilityId}" or custom
+     */
+    id: TestSpecificationId;
+
+    /**
+     * API version for test specification format
+     */
+    apiVersion: 'test/v0.1';
+
+    /**
+     * Kind discriminator
+     */
+    kind: 'TestSpecification';
+
+    /**
+     * Test edilecek capability'nin ID'si
+     */
+    targetCapabilityId: CapabilityId;
+
+    /**
+     * Human-readable title
+     */
+    title: string;
+
+    /**
+     * Optional description
+     */
+    description?: string;
+
+    /**
+     * Version of this test specification
+     */
+    version: string;
+
+    /**
+     * Test specification content
+     */
+    spec: TestSpec;
+
+    /**
+     * Test metadata
+     */
+    metadata?: TestMetadata;
+
+    /**
+     * Tags for categorization
+     */
+    tags?: string[];
+
+    /**
+     * Raw ivy.node / ivy.agent manifest this specification was derived
+     * from. Lets test tooling execute capabilities that are not present in
+     * the node registry (agents) via `flow.test.run(id, { manifest })`.
+     */
+    sourceManifest?: JSONValue;
+
+    /**
+     * Allow domain-specific extensions while maintaining type safety
+     */
+    [key: string]: unknown;
+  }
+
+  /**
+   * Test case result for a single test case
+   */
+  export interface TestCaseResult {
+    /**
+     * Test case ID
+     */
+    caseId: string;
+    /**
+     * Test status
+     */
+    status: 'pass' | 'fail' | 'skip' | 'error';
+    /**
+     * Execution duration in milliseconds
+     */
+    durationMs: number;
+    /**
+     * Test output
+     */
+    output?: JSONValue;
+    /**
+     * Error message if test failed
+     */
+    error?: string;
+    /**
+     * Assertion results
+     */
+    assertions?: {
+      schema?: { passed: boolean };
+      error?: {
+        passed: boolean;
+        expected?: string;
+        actual?: string;
+      };
+      [key: string]: unknown;
+    };
+  }
+
+  /**
+   * Test report for a capability
+   */
+  export interface TestReport {
+    /**
+     * Unique report identifier
+     */
+    reportId: string;
+    /**
+     * Capability ID that was tested
+     */
+    capabilityId: CapabilityId;
+    /**
+     * Version of the capability that was tested
+     */
+    capabilityVersion: string;
+    /**
+     * Test specification version
+     */
+    specVersion: string;
+    /**
+     * Timestamp when report was generated
+     */
+    timestampMs: number;
+    /**
+     * Test runner information
+     */
+    runner: {
+      /**
+       * Runner version
+       */
+      version: string;
+      /**
+       * Execution environment
+       */
+      environment: string;
+    };
+    /**
+     * Test summary
+     */
+    summary: {
+      /**
+       * Test tier
+       */
+      tier: 'draft' | 'verified' | 'certified';
+      /**
+       * Overall test status
+       */
+      status: 'pass' | 'fail' | 'flaky';
+      /**
+       * Total number of test cases
+       */
+      totalCases: number;
+      /**
+       * Number of passed test cases
+       */
+      passedCases: number;
+      /**
+       * Number of failed test cases
+       */
+      failedCases: number;
+      /**
+       * Number of skipped test cases
+       */
+      skippedCases: number;
+      /**
+       * Total execution duration in milliseconds
+       */
+      durationMs: number;
+    };
+    /**
+     * Individual test case results
+     */
+    cases: TestCaseResult[];
+  }
+}

package/types/punica.module.activityBar.d.ts

@@ -1,21 +0,0 @@
-declare module 'punica' {
-  export namespace ActivityBar {
-    type Alignment = 'primary' | 'secondary';
-    type ItemType = 'normal' | 'menu';
-
-    interface IItem {
-      id: string;
-      name: string;
-      alignment: Alignment;
-      title: string;
-      icon: string;
-    }
-
-    interface IActivityBarManager {
-      addItem(item: IItem): void;
-      removeItem(itemId: string): void;
-    }
-
-    const manager: IActivityBarManager;
-  }
-}

package/types/punica.module.commands.d.ts

@@ -1,21 +0,0 @@
-declare module 'punica' {
-  export namespace Commands {
-    interface IDisposable {
-      dispose(): void;
-    }
-
-    interface ICommand {
-      title: string;
-      disposable?: Disposable;
-      execute(...args: any[]): void;
-    }
-
-    interface ICommandManager {
-      registerCommand(commandName: string, command: ICommand): void;
-      executeCommand(commandName: string, ...args: any[]): void;
-      disposeCommand(commandName: string): void;
-    }
-
-    const manager: ICommandManager;
-  }
-}

package/types/punica.module.dragDrop.d.ts

@@ -1,23 +0,0 @@
-declare module 'punica' {
-  export namespace DragDrop {
-    type DragDropEvents = 'dragging' | 'dragStart' | 'dragStop';
-    type Events = { [key in DragDropEvents]: string };
-    type Point = {
-      x: number;
-      y: number;
-    };
-    type PositionDetail = {
-      offsetX: number;
-      offsetY: number;
-      pageX: number;
-      pageY: number;
-      clientX: number;
-      clientY: number;
-    };
-    interface IServiceDragDrop {
-      handleDragStart(event: MouseEvent): void;
-      handleDragging(event: MouseEvent): void;
-      handleDragStop(event: MouseEvent): void;
-    }
-  }
-}