@gitgov/core 1.0.0

package/dist/src/schemas/generated/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/schemas/generated/index.ts"],"names":[],"mappings":"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"}

package/dist/src/schemas/generated/index.js

@@ -0,0 +1,48 @@
+/**
+ * GitGovernance Protocol Schemas
+ *
+ * Auto-generated from blueprints. Do not edit manually.
+ * Run 'pnpm sync:schemas' to update.
+ */
+import actorRecordSchema from "./actor_record_schema.json";
+import agentRecordSchema from "./agent_record_schema.json";
+import changelogRecordSchema from "./changelog_record_schema.json";
+import cycleRecordSchema from "./cycle_record_schema.json";
+import embeddedMetadataSchema from "./embedded_metadata_schema.json";
+import executionRecordSchema from "./execution_record_schema.json";
+import feedbackRecordSchema from "./feedback_record_schema.json";
+import taskRecordSchema from "./task_record_schema.json";
+import workflowMethodologyRecordSchema from "./workflow_methodology_record_schema.json";
+/**
+ * All GitGovernance protocol schemas
+ */
+export const Schemas = {
+    ActorRecord: actorRecordSchema,
+    AgentRecord: agentRecordSchema,
+    ChangelogRecord: changelogRecordSchema,
+    CycleRecord: cycleRecordSchema,
+    EmbeddedMetadata: embeddedMetadataSchema,
+    ExecutionRecord: executionRecordSchema,
+    FeedbackRecord: feedbackRecordSchema,
+    TaskRecord: taskRecordSchema,
+    WorkflowMethodologyRecord: workflowMethodologyRecordSchema,
+};
+/**
+ * Get a schema by name
+ */
+export function getSchema(name) {
+    return Schemas[name];
+}
+/**
+ * Get all schema names
+ */
+export function getSchemaNames() {
+    return Object.keys(Schemas);
+}
+/**
+ * Check if a schema exists
+ */
+export function hasSchema(name) {
+    return name in Schemas;
+}
+//# sourceMappingURL=index.js.map

package/dist/src/schemas/generated/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/schemas/generated/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,iBAAiB,MAAM,4BAA4B,CAAC;AAC3D,OAAO,iBAAiB,MAAM,4BAA4B,CAAC;AAC3D,OAAO,qBAAqB,MAAM,gCAAgC,CAAC;AACnE,OAAO,iBAAiB,MAAM,4BAA4B,CAAC;AAC3D,OAAO,sBAAsB,MAAM,iCAAiC,CAAC;AACrE,OAAO,qBAAqB,MAAM,gCAAgC,CAAC;AACnE,OAAO,oBAAoB,MAAM,+BAA+B,CAAC;AACjE,OAAO,gBAAgB,MAAM,2BAA2B,CAAC;AACzD,OAAO,+BAA+B,MAAM,2CAA2C,CAAC;AAExF;;GAEG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,WAAW,EAAE,iBAAiB;IAC9B,WAAW,EAAE,iBAAiB;IAC9B,eAAe,EAAE,qBAAqB;IACtC,WAAW,EAAE,iBAAiB;IAC9B,gBAAgB,EAAE,sBAAsB;IACxC,eAAe,EAAE,qBAAqB;IACtC,cAAc,EAAE,oBAAoB;IACpC,UAAU,EAAE,gBAAgB;IAC5B,yBAAyB,EAAE,+BAA+B;CAClD,CAAC;AAgBX;;GAEG;AACH,MAAM,UAAU,SAAS,CAAC,IAAgB;IACxC,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC;AACvB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,cAAc;IAC5B,OAAO,MAAM,CAAC,IAAI,CAAC,OAAO,CAAiB,CAAC;AAC9C,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,SAAS,CAAC,IAAY;IACpC,OAAO,IAAI,IAAI,OAAO,CAAC;AACzB,CAAC"}

package/dist/src/schemas/generated/task_record_schema.json

@@ -0,0 +1,103 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "$id": "task_record_schema.json",
+    "title": "TaskRecord",
+    "description": "Canonical schema for task records as defined in task_protocol.md",
+    "additionalProperties": false,
+    "type": "object",
+    "required": [
+        "id",
+        "title",
+        "status",
+        "priority",
+        "description",
+        "tags"
+    ],
+    "properties": {
+        "id": {
+            "type": "string",
+            "pattern": "^\\d{10}-task-[a-z0-9-]{1,50}$",
+            "maxLength": 70,
+            "description": "Unique identifier for the task",
+            "examples": [
+                "1752274500-task-implementar-auth",
+                "1752347700-task-fix-logging"
+            ]
+        },
+        "title": {
+            "type": "string",
+            "minLength": 3,
+            "maxLength": 150,
+            "description": "A brief, human-readable title for the task. Used to generate the ID slug."
+        },
+        "cycleIds": {
+            "type": "array",
+            "items": {
+                "type": "string",
+                "pattern": "^\\d{10}-cycle-[a-z0-9-]{1,50}$"
+            },
+            "description": "Optional. The IDs of the strategic cycles this task belongs to."
+        },
+        "status": {
+            "type": "string",
+            "enum": [
+                "draft",
+                "review",
+                "ready",
+                "active",
+                "done",
+                "archived",
+                "paused",
+                "discarded"
+            ],
+            "maxLength": 40,
+            "description": "Current state of the task in the institutional flow"
+        },
+        "priority": {
+            "type": "string",
+            "enum": [
+                "low",
+                "medium",
+                "high",
+                "critical"
+            ],
+            "maxLength": 40,
+            "description": "Strategic or tactical priority level"
+        },
+        "description": {
+            "type": "string",
+            "minLength": 10,
+            "maxLength": 22000,
+            "description": "Functional, technical or strategic summary of the objective"
+        },
+        "tags": {
+            "type": "array",
+            "items": {
+                "type": "string",
+                "pattern": "^[a-z0-9-]+(:[a-z0-9-:]+)*$"
+            },
+            "description": "List of key:value tags for categorization and role suggestion (e.g., 'skill:react', 'role:agent:developer'). Can be an empty array."
+        },
+        "references": {
+            "type": "array",
+            "items": {
+                "type": "string",
+                "maxLength": 500
+            },
+            "description": "Valid links or files, when mentioned"
+        },
+        "notes": {
+            "type": "string",
+            "maxLength": 3000,
+            "description": "Additional comments, decisions made or added context"
+        }
+    },
+    "examples": [
+        {
+            "id": "1752274500-task-implementar-adapter-github",
+            "status": "in_progress",
+            "priority": "high",
+            "description": "Implementar adapter completo para GitHub Issues como TaskLifecycle Store"
+        }
+    ]
+}

package/dist/src/schemas/generated/workflow_methodology_record_schema.json

@@ -0,0 +1,393 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "$id": "workflow_methodology_schema.json",
+    "title": "WorkflowMethodologyRecord",
+    "description": "Complete schema for workflow methodology configuration files that define state transitions, signatures, and view configurations",
+    "type": "object",
+    "required": [
+        "version",
+        "name",
+        "state_transitions"
+    ],
+    "additionalProperties": false,
+    "properties": {
+        "$schema": {
+            "type": "string",
+            "description": "JSON Schema reference"
+        },
+        "version": {
+            "type": "string",
+            "pattern": "^\\d+\\.\\d+\\.\\d+$",
+            "description": "Semantic version of the methodology configuration"
+        },
+        "name": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 100,
+            "description": "Human-readable name of the methodology"
+        },
+        "description": {
+            "type": "string",
+            "maxLength": 500,
+            "description": "Brief description of the methodology's purpose and scope"
+        },
+        "state_transitions": {
+            "type": "object",
+            "description": "Defines valid state transitions and their requirements",
+            "additionalProperties": {
+                "type": "object",
+                "required": [
+                    "from",
+                    "requires"
+                ],
+                "additionalProperties": false,
+                "properties": {
+                    "from": {
+                        "type": "array",
+                        "items": {
+                            "type": "string",
+                            "enum": [
+                                "draft",
+                                "review",
+                                "ready",
+                                "active",
+                                "done",
+                                "archived",
+                                "paused",
+                                "discarded"
+                            ]
+                        },
+                        "minItems": 1,
+                        "description": "Valid source states for this transition"
+                    },
+                    "requires": {
+                        "type": "object",
+                        "additionalProperties": false,
+                        "properties": {
+                            "command": {
+                                "type": "string",
+                                "description": "CLI command that triggers this transition"
+                            },
+                            "event": {
+                                "type": "string",
+                                "description": "System event that triggers this transition"
+                            },
+                            "signatures": {
+                                "type": "object",
+                                "description": "Signature requirements keyed by guild",
+                                "additionalProperties": {
+                                    "type": "object",
+                                    "required": [
+                                        "role",
+                                        "capability_roles",
+                                        "min_approvals"
+                                    ],
+                                    "additionalProperties": false,
+                                    "properties": {
+                                        "role": {
+                                            "type": "string",
+                                            "description": "Required signature role"
+                                        },
+                                        "capability_roles": {
+                                            "type": "array",
+                                            "items": {
+                                                "type": "string"
+                                            },
+                                            "minItems": 1,
+                                            "description": "Required capability roles in actor record"
+                                        },
+                                        "min_approvals": {
+                                            "type": "integer",
+                                            "minimum": 1,
+                                            "description": "Minimum number of required approvals"
+                                        },
+                                        "actor_type": {
+                                            "type": "string",
+                                            "enum": [
+                                                "human",
+                                                "agent"
+                                            ],
+                                            "description": "Optional: restrict to specific actor type"
+                                        },
+                                        "specific_actors": {
+                                            "type": "array",
+                                            "items": {
+                                                "type": "string"
+                                            },
+                                            "description": "Optional: specific actors that can sign"
+                                        }
+                                    }
+                                }
+                            },
+                            "custom_rules": {
+                                "type": "array",
+                                "items": {
+                                    "type": "string"
+                                },
+                                "description": "List of custom rule identifiers to validate"
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        "custom_rules": {
+            "type": "object",
+            "description": "Definitions for custom validation rules",
+            "additionalProperties": {
+                "type": "object",
+                "required": [
+                    "description",
+                    "validation"
+                ],
+                "additionalProperties": false,
+                "properties": {
+                    "description": {
+                        "type": "string",
+                        "maxLength": 200,
+                        "description": "Human-readable description of the rule"
+                    },
+                    "validation": {
+                        "type": "string",
+                        "enum": [
+                            "assignment_required",
+                            "sprint_capacity",
+                            "epic_complexity",
+                            "custom",
+                            "javascript"
+                        ],
+                        "description": "Validation type identifier"
+                    },
+                    "parameters": {
+                        "type": "object",
+                        "description": "Optional parameters for the validation rule"
+                    },
+                    "javascript_function": {
+                        "type": "string",
+                        "description": "JavaScript function code for 'javascript' validation type. Must return Promise<boolean>"
+                    },
+                    "module_path": {
+                        "type": "string",
+                        "description": "Path to external module for custom validation (alternative to javascript_function)"
+                    }
+                }
+            }
+        },
+        "view_configs": {
+            "type": "object",
+            "description": "Visual representation configurations for different view types",
+            "additionalProperties": {
+                "type": "object",
+                "required": [
+                    "columns"
+                ],
+                "additionalProperties": false,
+                "properties": {
+                    "columns": {
+                        "type": "object",
+                        "description": "Column definitions mapping visual names to task states",
+                        "additionalProperties": {
+                            "type": "array",
+                            "items": {
+                                "type": "string",
+                                "enum": [
+                                    "draft",
+                                    "review",
+                                    "ready",
+                                    "active",
+                                    "done",
+                                    "archived",
+                                    "paused",
+                                    "discarded"
+                                ]
+                            },
+                            "minItems": 1
+                        }
+                    },
+                    "theme": {
+                        "type": "string",
+                        "enum": [
+                            "default",
+                            "dark",
+                            "minimal",
+                            "corporate"
+                        ],
+                        "description": "Visual theme for this view configuration"
+                    },
+                    "layout": {
+                        "type": "string",
+                        "enum": [
+                            "horizontal",
+                            "vertical",
+                            "grid"
+                        ],
+                        "description": "Layout direction for the view"
+                    }
+                }
+            }
+        },
+        "agent_integration": {
+            "type": "object",
+            "description": "Optional agent automation configuration for methodology",
+            "additionalProperties": false,
+            "properties": {
+                "description": {
+                    "type": "string",
+                    "maxLength": 200,
+                    "description": "Brief description of the agent integration"
+                },
+                "required_agents": {
+                    "type": "array",
+                    "description": "List of agents required for this methodology",
+                    "items": {
+                        "type": "object",
+                        "required": [
+                            "id",
+                            "gremio",
+                            "engine"
+                        ],
+                        "additionalProperties": false,
+                        "properties": {
+                            "id": {
+                                "type": "string",
+                                "pattern": "^agent:[a-z0-9:-]+$",
+                                "description": "Unique agent identifier"
+                            },
+                            "gremio": {
+                                "type": "string",
+                                "enum": [
+                                    "design",
+                                    "intelligence",
+                                    "strategy",
+                                    "operations",
+                                    "quality"
+                                ],
+                                "description": "Agent guild classification"
+                            },
+                            "engine": {
+                                "type": "object",
+                                "oneOf": [
+                                    {
+                                        "required": [
+                                            "type"
+                                        ],
+                                        "properties": {
+                                            "type": {
+                                                "const": "local"
+                                            },
+                                            "runtime": {
+                                                "type": "string"
+                                            },
+                                            "entrypoint": {
+                                                "type": "string"
+                                            },
+                                            "function": {
+                                                "type": "string"
+                                            }
+                                        }
+                                    },
+                                    {
+                                        "required": [
+                                            "type"
+                                        ],
+                                        "properties": {
+                                            "type": {
+                                                "const": "api"
+                                            },
+                                            "url": {
+                                                "type": "string"
+                                            },
+                                            "method": {
+                                                "type": "string",
+                                                "enum": [
+                                                    "POST",
+                                                    "GET"
+                                                ]
+                                            },
+                                            "auth": {
+                                                "type": "object"
+                                            }
+                                        }
+                                    },
+                                    {
+                                        "required": [
+                                            "type"
+                                        ],
+                                        "properties": {
+                                            "type": {
+                                                "const": "mcp"
+                                            },
+                                            "url": {
+                                                "type": "string"
+                                            },
+                                            "auth": {
+                                                "type": "object"
+                                            }
+                                        }
+                                    }
+                                ]
+                            },
+                            "triggers": {
+                                "type": "array",
+                                "description": "Event triggers for this agent",
+                                "items": {
+                                    "type": "object",
+                                    "required": [
+                                        "event",
+                                        "action"
+                                    ],
+                                    "additionalProperties": false,
+                                    "properties": {
+                                        "event": {
+                                            "type": "string",
+                                            "description": "Event that triggers the agent"
+                                        },
+                                        "action": {
+                                            "type": "string",
+                                            "description": "Action the agent should perform"
+                                        }
+                                    }
+                                }
+                            },
+                            "knowledge_dependencies": {
+                                "type": "array",
+                                "description": "Knowledge files this agent depends on",
+                                "items": {
+                                    "type": "string"
+                                }
+                            }
+                        }
+                    }
+                },
+                "automation_rules": {
+                    "type": "array",
+                    "description": "Automation rules linking triggers to agents",
+                    "items": {
+                        "type": "object",
+                        "required": [
+                            "trigger",
+                            "agent",
+                            "action"
+                        ],
+                        "additionalProperties": false,
+                        "properties": {
+                            "trigger": {
+                                "type": "string",
+                                "description": "Event or condition that triggers automation"
+                            },
+                            "agent": {
+                                "type": "string",
+                                "pattern": "^agent:[a-z0-9:-]+$",
+                                "description": "Agent ID that handles this automation"
+                            },
+                            "action": {
+                                "type": "string",
+                                "description": "Specific action the agent should perform"
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

package/dist/src/schemas/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./generated";
+export * from "./schema_cache";
+export * from "./errors";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,UAAU,CAAA"}

package/dist/src/schemas/index.js

@@ -0,0 +1,4 @@
+export * from "./generated";
+export * from "./schema_cache";
+export * from "./errors";
+//# sourceMappingURL=index.js.map

package/dist/src/schemas/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/schemas/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,UAAU,CAAA"}

package/dist/src/schemas/schema_cache.d.ts

@@ -0,0 +1,39 @@
+import type { ValidateFunction } from "ajv";
+/**
+ * Singleton cache for schema validators to avoid repeated I/O and AJV compilation.
+ * Improves performance by caching compiled validators for schema files.
+ */
+export declare class SchemaValidationCache {
+    private static validators;
+    private static schemaValidators;
+    private static ajv;
+    /**
+     * Gets or creates a cached validator for the specified schema path.
+     * @param schemaPath Absolute path to the YAML schema file
+     * @returns Compiled AJV validator function
+     */
+    static getValidator(schemaPath: string): ValidateFunction;
+    /**
+     * Gets or creates a cached validator for a schema object.
+     * @param schema The schema object (already parsed YAML/JSON)
+     * @returns Compiled AJV validator function
+     */
+    static getValidatorFromSchema<T = unknown>(schema: object): ValidateFunction<T>;
+    /**
+     * Pre-loads referenced schema files for $ref resolution.
+     * Uses direct imports and dynamic iteration.
+     */
+    private static preloadSchemas;
+    /**
+     * Clears the cache (useful for testing or schema updates).
+     */
+    static clearCache(): void;
+    /**
+     * Gets cache statistics for monitoring.
+     */
+    static getCacheStats(): {
+        cachedSchemas: number;
+        schemasLoaded: string[];
+    };
+}
+//# sourceMappingURL=schema_cache.d.ts.map

package/dist/src/schemas/schema_cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema_cache.d.ts","sourceRoot":"","sources":["../../../src/schemas/schema_cache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,KAAK,CAAC;AAQ5C;;;GAGG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAuC;IAChE,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAuC;IACtE,OAAO,CAAC,MAAM,CAAC,GAAG,CAAoB;IAEtC;;;;OAIG;IACH,MAAM,CAAC,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB;IAmBzD;;;;OAIG;IACH,MAAM,CAAC,sBAAsB,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAAC,CAAC,CAAC;IA0B/E;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IA4B7B;;OAEG;IACH,MAAM,CAAC,UAAU,IAAI,IAAI;IAMzB;;OAEG;IACH,MAAM,CAAC,aAAa,IAAI;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,EAAE,CAAA;KAAE;CAM3E"}