@agilno-tech/rivet 0.1.0-alpha.0

package/schemas/providers.schema.json

@@ -0,0 +1,142 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://schemas.rivet.dev/rivet/v2/providers.schema.json",
+  "title": "Agilno tracked provider references",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "providers"
+  ],
+  "properties": {
+    "schemaVersion": {
+      "type": "integer",
+      "const": 1
+    },
+    "providers": {
+      "type": "array",
+      "minItems": 1,
+      "maxItems": 64,
+      "items": {
+        "$ref": "#/$defs/provider"
+      }
+    }
+  },
+  "$defs": {
+    "id": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 64,
+      "pattern": "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$"
+    },
+    "envName": {
+      "type": "string",
+      "minLength": 2,
+      "maxLength": 128,
+      "pattern": "^[A-Z][A-Z0-9_]*$"
+    },
+    "provider": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "kind",
+        "mode",
+        "capabilities"
+      ],
+      "properties": {
+        "id": {
+          "$ref": "#/$defs/id"
+        },
+        "kind": {
+          "enum": [
+            "jira",
+            "linear",
+            "confluence",
+            "figma",
+            "git-ci",
+            "generic"
+          ]
+        },
+        "mode": {
+          "enum": [
+            "disabled",
+            "read-only",
+            "read-write-with-approval"
+          ]
+        },
+        "capabilities": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 64,
+          "uniqueItems": true,
+          "items": {
+            "$ref": "#/$defs/id"
+          }
+        },
+        "resourceIds": {
+          "type": "array",
+          "maxItems": 64,
+          "uniqueItems": true,
+          "items": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 200,
+            "pattern": "^[^\\u0000\\r\\n]+$"
+          }
+        },
+        "endpoint": {
+          "type": "string",
+          "minLength": 8,
+          "maxLength": 2048,
+          "pattern": "^https?://"
+        },
+        "credentials": {
+          "type": "object",
+          "additionalProperties": false,
+          "minProperties": 1,
+          "properties": {
+            "apiTokenEnv": {
+              "$ref": "#/$defs/envName"
+            },
+            "accessTokenEnv": {
+              "$ref": "#/$defs/envName"
+            },
+            "tokenEnv": {
+              "$ref": "#/$defs/envName"
+            },
+            "usernameEnv": {
+              "$ref": "#/$defs/envName"
+            }
+          }
+        },
+        "transport": {
+          "enum": [
+            "harness-mcp",
+            "direct-api",
+            "local-cli"
+          ]
+        },
+        "projectIds": {
+          "type": "array",
+          "maxItems": 64,
+          "uniqueItems": true,
+          "items": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 200
+          }
+        },
+        "tools": {
+          "type": "array",
+          "maxItems": 64,
+          "uniqueItems": true,
+          "items": {
+            "type": "string",
+            "pattern": "^[A-Za-z0-9_.:-]{1,128}$"
+          }
+        }
+      }
+    }
+  }
+}

package/schemas/quality.schema.json

@@ -0,0 +1,50 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://schemas.rivet.dev/rivet/v2/quality.schema.json",
+  "title": "Agilno tracked quality policy",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "providerRefs", "completionProfileRefs", "commandGates", "expectations", "evidence"],
+  "properties": {
+    "schemaVersion": { "type": "integer", "const": 1 },
+    "providerRefs": { "type": "array", "minItems": 1, "maxItems": 64, "uniqueItems": true, "items": { "$ref": "#/$defs/id" } },
+    "completionProfileRefs": { "type": "array", "minItems": 1, "maxItems": 32, "uniqueItems": true, "items": { "$ref": "#/$defs/id" } },
+    "commandGates": { "type": "array", "minItems": 1, "maxItems": 32, "items": { "$ref": "#/$defs/commandGate" } },
+    "expectations": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["storybook", "playwright", "accessibility", "security", "visual"],
+      "properties": {
+        "storybook": { "enum": ["optional", "required"] },
+        "playwright": { "enum": ["optional", "required"] },
+        "accessibility": { "enum": ["none", "wcag-a", "wcag-aa"] },
+        "security": { "enum": ["required", "not-applicable-with-approval"] },
+        "visual": { "enum": ["none", "automated", "human-baseline"] }
+      }
+    },
+    "evidence": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["requiredTypes", "requireHumanBaseline", "requireHumanFinal"],
+      "properties": {
+        "requiredTypes": { "type": "array", "minItems": 1, "maxItems": 8, "uniqueItems": true, "items": { "$ref": "#/$defs/evidenceType" } },
+        "requireHumanBaseline": { "type": "boolean" },
+        "requireHumanFinal": { "type": "boolean", "const": true }
+      }
+    }
+  },
+  "$defs": {
+    "id": { "type": "string", "minLength": 1, "maxLength": 64, "pattern": "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$" },
+    "evidenceType": { "enum": ["commit", "test", "journey", "screenshot", "report", "review", "human-approval", "external-update"] },
+    "commandGate": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "command", "required"],
+      "properties": {
+        "id": { "$ref": "#/$defs/id" },
+        "command": { "enum": ["build", "test", "lint", "typecheck", "dev", "check"] },
+        "required": { "type": "boolean" }
+      }
+    }
+  }
+}

package/schemas/work-action.schema.json

@@ -0,0 +1,44 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://schemas.rivet.dev/rivet/v2/work-action.schema.json",
+  "title": "Agilno host work action",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "kind",
+    "runId",
+    "runtimeVersion",
+    "nodeId",
+    "intentId",
+    "idempotencyKey",
+    "reservationId",
+    "attempt",
+    "payload"
+  ],
+  "properties": {
+    "schemaVersion": { "type": "integer", "const": 1 },
+    "kind": { "type": "string", "const": "agilno.work-action" },
+    "runId": { "$ref": "#/$defs/id" },
+    "runtimeVersion": { "type": "integer", "minimum": 0, "maximum": 9007199254740990 },
+    "nodeId": { "$ref": "#/$defs/id" },
+    "intentId": { "$ref": "#/$defs/id" },
+    "idempotencyKey": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 256,
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9:._-]*$"
+    },
+    "reservationId": { "$ref": "#/$defs/id" },
+    "attempt": { "type": "integer", "minimum": 1, "maximum": 10000 },
+    "payload": { "type": "string", "minLength": 1, "maxLength": 131072 }
+  },
+  "$defs": {
+    "id": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 64,
+      "pattern": "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$"
+    }
+  }
+}

package/schemas/work-request.schema.json

@@ -0,0 +1,253 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://schemas.rivet.dev/rivet/v2/work-request.schema.json",
+  "title": "Agilno immutable work request",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "source",
+    "title",
+    "description",
+    "acceptanceCriteria",
+    "contextRefs",
+    "capturedAt",
+    "digest"
+  ],
+  "properties": {
+    "schemaVersion": {
+      "type": "integer",
+      "const": 1
+    },
+    "source": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "kind",
+        "ref"
+      ],
+      "properties": {
+        "kind": {
+          "enum": [
+            "inline",
+            "markdown",
+            "jira",
+            "linear",
+            "host-observation"
+          ]
+        },
+        "ref": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 512
+        },
+        "revision": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 256
+        },
+        "url": {
+          "type": "string",
+          "minLength": 9,
+          "maxLength": 2048,
+          "pattern": "^https://"
+        }
+      }
+    },
+    "title": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 500
+    },
+    "description": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 131072
+    },
+    "acceptanceCriteria": {
+      "type": "array",
+      "minItems": 1,
+      "maxItems": 256,
+      "uniqueItems": true,
+      "items": {
+        "type": "string",
+        "minLength": 1,
+        "maxLength": 4096
+      }
+    },
+    "contextRefs": {
+      "type": "array",
+      "maxItems": 256,
+      "uniqueItems": true,
+      "items": {
+        "type": "string",
+        "minLength": 1,
+        "maxLength": 2048
+      }
+    },
+    "capturedAt": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "digest": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    },
+    "context": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "sources",
+        "userAcceptanceCriteria"
+      ],
+      "properties": {
+        "sources": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 16,
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+              "provider",
+              "transport",
+              "assurance",
+              "contentDigest",
+              "content",
+              "url",
+              "capturedAt",
+              "providerId",
+              "projectId",
+              "resourceId",
+              "revision",
+              "tool"
+            ],
+            "properties": {
+              "provider": {
+                "enum": [
+                  "jira",
+                  "linear",
+                  "figma",
+                  "confluence",
+                  "generic"
+                ]
+              },
+              "transport": {
+                "const": "harness-mcp"
+              },
+              "assurance": {
+                "const": "harness-observed"
+              },
+              "contentDigest": {
+                "type": "string",
+                "pattern": "^[a-f0-9]{64}$"
+              },
+              "content": {
+                "type": "object"
+              },
+              "url": {
+                "type": "string",
+                "maxLength": 2048,
+                "pattern": "^https://"
+              },
+              "capturedAt": {
+                "type": "string",
+                "format": "date-time"
+              },
+              "providerId": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 200
+              },
+              "projectId": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 200
+              },
+              "resourceId": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 200
+              },
+              "revision": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 200
+              },
+              "tool": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 200
+              }
+            }
+          }
+        },
+        "userAcceptanceCriteria": {
+          "type": "array",
+          "maxItems": 256,
+          "uniqueItems": true,
+          "items": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 4096
+          }
+        }
+      }
+    },
+    "criteriaProvenance": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "sourceAcceptanceCriteria",
+        "userAcceptanceCriteria"
+      ],
+      "properties": {
+        "sourceAcceptanceCriteria": {
+          "type": "array",
+          "maxItems": 256,
+          "uniqueItems": true,
+          "items": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 4096
+          }
+        },
+        "userAcceptanceCriteria": {
+          "type": "array",
+          "maxItems": 256,
+          "uniqueItems": true,
+          "items": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 4096
+          },
+          "minItems": 1
+        }
+      }
+    }
+  },
+  "allOf": [
+    {
+      "if": {
+        "required": [
+          "criteriaProvenance"
+        ]
+      },
+      "then": {
+        "properties": {
+          "source": {
+            "properties": {
+              "kind": {
+                "enum": [
+                  "jira",
+                  "linear"
+                ]
+              }
+            },
+            "type": "object"
+          }
+        }
+      }
+    }
+  ]
+}

package/src/adapters/confluence.js

@@ -0,0 +1,138 @@
+import {
+  boundedString,
+  captureRecord,
+  createAdapter,
+  createProviderWriteGovernance,
+  createProviderWireBody,
+  createSourceEnvelope,
+  executeGovernedWrite,
+  failProvider,
+  immutableRedactedJson,
+  providerTimestamp,
+  sanitizeProviderLink,
+  snapshotProviderJson,
+} from './contract.js';
+import { createProviderHttpClient } from './http.js';
+
+const READ = Object.freeze(['page']);
+const WRITE = Object.freeze(['page-update']);
+const PAGE_ID = /^[1-9][0-9]{0,63}$/;
+
+function canonicalParentIds(value) {
+  const parents = value?.ancestors === undefined
+    ? (value?.parentId === undefined ? [] : [{ id: value.parentId }])
+    : value.ancestors;
+  if (!Array.isArray(parents)) failProvider('remote', { provider: 'confluence', retryClassification: 'permanent' });
+  const ids = [];
+  for (const parent of parents) {
+    if (!parent || typeof parent !== 'object' || Array.isArray(parent)
+      || typeof parent.id !== 'string' || !PAGE_ID.test(parent.id)) {
+      failProvider('remote', { provider: 'confluence', retryClassification: 'permanent' });
+    }
+    ids.push(parent.id);
+  }
+  if (new Set(ids).size !== ids.length) failProvider('remote', { provider: 'confluence', retryClassification: 'permanent' });
+  return ids;
+}
+
+function validatePage(value, expectedId, full = false) {
+  try {
+    if (!value || typeof value !== 'object' || Array.isArray(value) || value.id !== expectedId
+      || typeof value.status !== 'string' || !Number.isSafeInteger(value.version?.number)) throw new Error();
+    if (full && (typeof value.title !== 'string' || !value.body || typeof value.body !== 'object'
+      || (value.ancestors !== undefined && (!Array.isArray(value.ancestors)
+        || value.ancestors.some(parent => !parent || typeof parent.id !== 'string' || !PAGE_ID.test(parent.id))
+        || new Set(value.ancestors.map(parent => parent.id)).size !== value.ancestors.length)))) throw new Error();
+    return value;
+  } catch { failProvider('remote', { provider: 'confluence', retryClassification: 'permanent' }); }
+}
+
+export function normalizeConfluence(raw) {
+  const source = snapshotProviderJson(raw);
+  const parentIds = canonicalParentIds(source);
+  const links = {};
+  for (const [key, value] of Object.entries(source?._links ?? {})) {
+    if (typeof value !== 'string') failProvider('remote', { provider: 'confluence', retryClassification: 'permanent' });
+    try { links[key] = sanitizeProviderLink(value); } catch { failProvider('remote', { provider: 'confluence', retryClassification: 'permanent' }); }
+  }
+  return immutableRedactedJson({
+    id: String(source?.id ?? ''), title: String(source?.title ?? ''), status: String(source?.status ?? ''),
+    content: source?.body?.storage ?? source?.body ?? null,
+    version: { number: Number(source?.version?.number ?? 0) },
+    parentIds,
+    links,
+  });
+}
+
+export function createConfluenceAdapter(input) {
+  const config = captureRecord(input, new Set([
+    'transport', 'baseUrl', 'headers', 'timeoutMs', 'maxResponseBytes', 'maxPages', 'clock', 'governance',
+  ]), ['transport', 'baseUrl'], 'invalid-config');
+  const now = config.clock ?? (() => new Date().toISOString());
+  if (typeof now !== 'function') failProvider('invalid-config', { provider: 'confluence' });
+  const governance = config.governance === undefined ? null : createProviderWriteGovernance(config.governance, 'confluence');
+  const http = createProviderHttpClient({
+    provider: 'confluence', baseUrl: config.baseUrl, transport: config.transport,
+    ...(config.headers === undefined ? {} : { headers: config.headers }),
+    ...(config.timeoutMs === undefined ? {} : { timeoutMs: config.timeoutMs }),
+    ...(config.maxResponseBytes === undefined ? {} : { maxResponseBytes: config.maxResponseBytes }),
+    ...(config.maxPages === undefined ? {} : { maxPages: config.maxPages }),
+  });
+
+  async function read(inputRead) {
+    const request = captureRecord(inputRead, new Set(['kind', 'id', 'signal']), ['kind', 'id']);
+    boundedString(request.kind, 16, /^page$/);
+    const id = boundedString(request.id, 64, PAGE_ID);
+    const response = await http.request({
+      method: 'GET', path: `/wiki/api/v2/pages/${id}?body-format=storage&include-ancestors=true`,
+      ...(request.signal === undefined ? {} : { signal: request.signal }),
+    });
+    validatePage(response.data, id, true);
+    return createSourceEnvelope({
+      provider: 'confluence', sourceId: id, sourceUrl: http.urlFor(`/wiki/pages/viewpage.action?pageId=${id}`),
+      fetchedAt: providerTimestamp(now, 'confluence'), fixtureSource: false, raw: response.data, normalized: normalizeConfluence(response.data),
+      retryClassification: 'none', capabilities: { read: READ, write: WRITE },
+    });
+  }
+
+  function write(inputWrite) {
+    if (!governance) failProvider('approval-required', { provider: 'confluence' });
+    return executeGovernedWrite(inputWrite, {
+      provider: 'confluence', actions: new Set(WRITE), governance,
+      async preflight(writeRequest) {
+        const id = boundedString(writeRequest.resourceId, 64, PAGE_ID);
+        const response = await http.request({ method: 'GET', path: `/wiki/api/v2/pages/${id}` });
+        validatePage(response.data, id);
+        return Object.freeze({
+          state: String(response.data?.status ?? ''), version: String(response.data?.version?.number ?? ''),
+          condition: response.headers.etag,
+        });
+      },
+      prepare(writeRequest, state) {
+        const id = boundedString(writeRequest.resourceId, 64, /^[1-9][0-9]*$/);
+        const payload = captureRecord(writeRequest.payload, new Set(['title', 'body', 'version']), ['title', 'body', 'version']);
+        const title = boundedString(payload.title, 512);
+        const body = boundedString(payload.body, 250_000);
+        if (!Number.isSafeInteger(payload.version) || payload.version !== Number(writeRequest.expectedVersion) + 1) failProvider('invalid-request', { provider: 'confluence' });
+        return Object.freeze({
+          method: 'PUT', path: `/wiki/api/v2/pages/${id}`,
+          headers: {
+            'idempotency-key': writeRequest.idempotencyKey,
+            'if-match': state.condition ?? writeRequest.expectedVersion,
+          },
+          wireBody: createProviderWireBody(writeRequest),
+        });
+      },
+      async mutate(_writeRequest, _state, prepared) {
+        const data = (await http.request(prepared)).data;
+        validatePage(data, _writeRequest.resourceId);
+        if (String(data.version.number) !== String(_writeRequest.payload.version)) failProvider('remote', { provider: 'confluence' });
+        return data;
+      },
+    });
+  }
+
+  return createAdapter({
+    provider: 'confluence', fixtureSource: false, capabilities: { read: READ, write: WRITE }, read, write,
+  });
+}