@a5c-ai/krate 5.0.1-staging.f672fe79b

package/tests/agent-stack-controller.test.js

@@ -0,0 +1,221 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createAgentStackController, createResource } from '../src/index.js';
+
+function makeStack(name, spec = {}) {
+  return createResource('AgentStack', { name, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    baseAgent: 'claude-code',
+    adapter: 'anthropic',
+    runtimeIdentity: { serviceAccountRef: 'sa-default' },
+    ...spec
+  });
+}
+
+function makeToolProfile(name) {
+  return createResource('AgentToolProfile', { name, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    filesystemPolicy: 'read-write',
+    approvalPolicyByTool: {}
+  });
+}
+
+function makeMcpServer(name) {
+  return createResource('AgentMcpServer', { name, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    transport: 'stdio',
+    scope: 'workspace'
+  });
+}
+
+function makeSkill(name, overrides = {}) {
+  return createResource('AgentSkill', { name, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    format: 'markdown',
+    sourceRef: 'git://repo/skills/' + name,
+    ...overrides
+  });
+}
+
+function makeSubagent(name, overrides = {}) {
+  return createResource('AgentSubagent', { name, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    rolePrompt: 'Test subagent',
+    taskKinds: ['code-review'],
+    ...overrides
+  });
+}
+
+function makeContextLabel(name) {
+  return createResource('AgentContextLabel', { name, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    promptFragment: 'context for ' + name,
+    allowedSources: ['manual']
+  });
+}
+
+function makeServiceAccount(name) {
+  return createResource('AgentServiceAccount', { name, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    namespace: 'krate-org-default',
+    serviceAccountName: name
+  });
+}
+
+function makeRoleBinding(name, subject) {
+  return createResource('AgentRoleBinding', { name, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    subject,
+    roleRef: 'agent-developer',
+    scope: 'namespace'
+  });
+}
+
+function makeSecretGrant(name, subject, purpose) {
+  return createResource('AgentSecretGrant', { name, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    subject,
+    secretRef: 'secret-' + purpose,
+    purpose
+  });
+}
+
+test('Stack with all refs present results in Ready=True', () => {
+  const controller = createAgentStackController();
+  const stack = makeStack('full-stack', {
+    toolPolicy: 'tool-profile-1',
+    mcpServerRefs: ['mcp-github'],
+    skillRefs: ['skill-review'],
+    subagentRefs: ['sub-linter'],
+    contextLabelRefs: ['ctx-security']
+  });
+
+  const resources = {
+    AgentStack: [stack],
+    AgentToolProfile: [makeToolProfile('tool-profile-1')],
+    AgentMcpServer: [makeMcpServer('mcp-github')],
+    AgentSkill: [makeSkill('skill-review')],
+    AgentSubagent: [makeSubagent('sub-linter')],
+    AgentContextLabel: [makeContextLabel('ctx-security')],
+    AgentServiceAccount: [makeServiceAccount('sa-default')],
+    AgentRoleBinding: [makeRoleBinding('rb-1', 'sa-default')],
+    AgentSecretGrant: [makeSecretGrant('sg-model', 'sa-default', 'model-provider')]
+  };
+
+  const result = controller.reconcileStack(stack, resources);
+  const readyCondition = result.conditions.find((c) => c.type === 'Ready');
+  assert.equal(readyCondition.status, 'True', 'Ready condition should be True when all refs are present');
+  assert.equal(result.validation, 'valid');
+  assert.equal(result.capabilities.tools.length, 1);
+  assert.equal(result.capabilities.mcpServers.length, 1);
+  assert.equal(result.capabilities.skills.length, 1);
+  assert.equal(result.capabilities.subagents.length, 1);
+  assert.equal(result.capabilities.contextLabels.length, 1);
+});
+
+test('Stack with missing MCP server results in McpHealthy=False and Ready=False', () => {
+  const controller = createAgentStackController();
+  const stack = makeStack('missing-mcp-stack', {
+    mcpServerRefs: ['mcp-github', 'mcp-missing']
+  });
+
+  const resources = {
+    AgentStack: [stack],
+    AgentMcpServer: [makeMcpServer('mcp-github')],
+    AgentServiceAccount: [makeServiceAccount('sa-default')],
+    AgentRoleBinding: [makeRoleBinding('rb-1', 'sa-default')],
+    AgentSecretGrant: [makeSecretGrant('sg-model', 'sa-default', 'model-provider')]
+  };
+
+  const result = controller.reconcileStack(stack, resources);
+  const mcpCondition = result.conditions.find((c) => c.type === 'McpHealthy');
+  const readyCondition = result.conditions.find((c) => c.type === 'Ready');
+  assert.equal(mcpCondition.status, 'False', 'McpHealthy should be False when MCP server is missing');
+  assert.equal(readyCondition.status, 'False', 'Ready should be False when McpHealthy is False');
+  assert.ok(mcpCondition.message.includes('mcp-missing'));
+});
+
+test('Stack with missing skill results in SkillsValidated=False and Ready=False', () => {
+  const controller = createAgentStackController();
+  const stack = makeStack('missing-skill-stack', {
+    skillRefs: ['skill-review', 'skill-ghost']
+  });
+
+  const resources = {
+    AgentStack: [stack],
+    AgentSkill: [makeSkill('skill-review')],
+    AgentServiceAccount: [makeServiceAccount('sa-default')],
+    AgentRoleBinding: [makeRoleBinding('rb-1', 'sa-default')],
+    AgentSecretGrant: [makeSecretGrant('sg-model', 'sa-default', 'model-provider')]
+  };
+
+  const result = controller.reconcileStack(stack, resources);
+  const skillsCondition = result.conditions.find((c) => c.type === 'SkillsValidated');
+  const readyCondition = result.conditions.find((c) => c.type === 'Ready');
+  assert.equal(skillsCondition.status, 'False', 'SkillsValidated should be False when skill is missing');
+  assert.equal(readyCondition.status, 'False', 'Ready should be False when SkillsValidated is False');
+  assert.ok(skillsCondition.message.includes('skill-ghost'));
+});
+
+test('Minimal stack with no capability refs results in Ready=True', () => {
+  const controller = createAgentStackController();
+  const stack = makeStack('minimal-stack');
+
+  const resources = {
+    AgentStack: [stack],
+    AgentServiceAccount: [makeServiceAccount('sa-default')],
+    AgentRoleBinding: [makeRoleBinding('rb-1', 'sa-default')],
+    AgentSecretGrant: [makeSecretGrant('sg-model', 'sa-default', 'model-provider')]
+  };
+
+  const result = controller.reconcileStack(stack, resources);
+  const readyCondition = result.conditions.find((c) => c.type === 'Ready');
+  assert.equal(readyCondition.status, 'True', 'Ready should be True for minimal stack with identity present');
+  assert.equal(result.validation, 'valid');
+  assert.equal(result.capabilities.tools.length, 0);
+  assert.equal(result.capabilities.mcpServers.length, 0);
+  assert.equal(result.capabilities.skills.length, 0);
+  assert.equal(result.capabilities.subagents.length, 0);
+  assert.equal(result.capabilities.contextLabels.length, 0);
+});
+
+test('listStackCapabilities returns correct normalized capability list', () => {
+  const controller = createAgentStackController();
+  const stack = makeStack('caps-stack', {
+    toolPolicy: 'tp-1',
+    mcpServerRefs: ['mcp-a', 'mcp-b'],
+    skillRefs: ['skill-x'],
+    subagentRefs: ['sub-y'],
+    contextLabelRefs: ['ctx-z']
+  });
+
+  const resources = {
+    AgentToolProfile: [makeToolProfile('tp-1')],
+    AgentMcpServer: [makeMcpServer('mcp-a')],
+    AgentSkill: [makeSkill('skill-x')],
+    AgentSubagent: [makeSubagent('sub-y')],
+    AgentContextLabel: [makeContextLabel('ctx-z')]
+  };
+
+  const capabilities = controller.listStackCapabilities(stack, resources);
+  assert.equal(capabilities.length, 6);
+
+  const tool = capabilities.find((c) => c.kind === 'tool');
+  assert.equal(tool.name, 'tp-1');
+  assert.equal(tool.status, 'resolved');
+
+  const mcpA = capabilities.find((c) => c.kind === 'mcp' && c.name === 'mcp-a');
+  assert.equal(mcpA.status, 'resolved');
+
+  const mcpB = capabilities.find((c) => c.kind === 'mcp' && c.name === 'mcp-b');
+  assert.equal(mcpB.status, 'missing');
+
+  const skill = capabilities.find((c) => c.kind === 'skill');
+  assert.equal(skill.status, 'resolved');
+
+  const subagent = capabilities.find((c) => c.kind === 'subagent');
+  assert.equal(subagent.status, 'resolved');
+
+  const ctxLabel = capabilities.find((c) => c.kind === 'contextLabel');
+  assert.equal(ctxLabel.status, 'resolved');
+});

package/tests/agent-trigger-controller.test.js

@@ -0,0 +1,211 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createAgentTriggerController, createResource } from '../src/index.js';
+
+function makeTriggerRule(name, spec = {}) {
+  return createResource('AgentTriggerRule', { name, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    sources: ['ci-failure'],
+    agentStack: 'debug-stack',
+    taskKind: 'diagnostic',
+    ...spec
+  });
+}
+
+function makeEvent(overrides = {}) {
+  return {
+    type: 'ci-failure',
+    repository: 'myapp',
+    ref: 'main',
+    actor: 'alice',
+    source: { kind: 'Pipeline', name: 'pipeline-123' },
+    ...overrides
+  };
+}
+
+function makeExecution(ruleName, eventUid, phase = 'Dispatched') {
+  const exec = createResource('AgentTriggerExecution', { name: `exec-${ruleName}-1`, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    triggerRule: ruleName,
+    sourceEvent: eventUid,
+    decision: phase
+  });
+  exec.status = { phase };
+  return exec;
+}
+
+// 1. matchRule: event type matches
+test('matchRule: event type matches rule sources', () => {
+  const controller = createAgentTriggerController();
+  const rule = makeTriggerRule('rule-1', { sources: ['ci-failure'] });
+  const event = makeEvent({ type: 'ci-failure' });
+
+  const result = controller.matchRule(rule, event);
+
+  assert.equal(result.matches, true);
+  assert.equal(result.reason, 'All conditions met');
+});
+
+// 2. matchRule: event type doesn't match
+test('matchRule: event type does not match rule sources', () => {
+  const controller = createAgentTriggerController();
+  const rule = makeTriggerRule('rule-2', { sources: ['ci-failure'] });
+  const event = makeEvent({ type: 'webhook' });
+
+  const result = controller.matchRule(rule, event);
+
+  assert.equal(result.matches, false);
+  assert.ok(result.reason.includes("'webhook'"), 'Reason should mention the event type');
+  assert.ok(result.reason.includes('ci-failure'), 'Reason should mention the expected source');
+});
+
+// 3. matchRule: repository scope match
+test('matchRule: repository scope matches', () => {
+  const controller = createAgentTriggerController();
+  const rule = makeTriggerRule('rule-3', { sources: ['ci-failure'], repository: 'myapp' });
+  const event = makeEvent({ type: 'ci-failure', repository: 'myapp' });
+
+  const result = controller.matchRule(rule, event);
+
+  assert.equal(result.matches, true);
+  assert.equal(result.reason, 'All conditions met');
+});
+
+// 4. matchRule: repository scope mismatch
+test('matchRule: repository scope mismatch', () => {
+  const controller = createAgentTriggerController();
+  const rule = makeTriggerRule('rule-4', { sources: ['ci-failure'], repository: 'myapp' });
+  const event = makeEvent({ type: 'ci-failure', repository: 'other' });
+
+  const result = controller.matchRule(rule, event);
+
+  assert.equal(result.matches, false);
+  assert.ok(result.reason.includes("'other'"), 'Reason should mention the event repository');
+  assert.ok(result.reason.includes("'myapp'"), 'Reason should mention the rule scope');
+});
+
+// 5. matchRule: actor filter
+test('matchRule: actor not in allowedActors', () => {
+  const controller = createAgentTriggerController();
+  const rule = makeTriggerRule('rule-5', { sources: ['ci-failure'], allowedActors: ['alice'] });
+  const event = makeEvent({ type: 'ci-failure', actor: 'bob' });
+
+  const result = controller.matchRule(rule, event);
+
+  assert.equal(result.matches, false);
+  assert.ok(result.reason.includes("'bob'"), 'Reason should mention the rejected actor');
+});
+
+// 6. evaluateEvent: deduplication
+test('evaluateEvent: marks duplicate when existing execution matches', () => {
+  const controller = createAgentTriggerController();
+  const rule = makeTriggerRule('rule-dedup');
+  const event = makeEvent();
+  const eventUid = `${event.type}:${event.source.kind}:${event.source.name}`;
+  const existingExecution = makeExecution('rule-dedup', eventUid, 'Dispatched');
+
+  const resources = {
+    AgentTriggerRule: [rule],
+    AgentTriggerExecution: [existingExecution]
+  };
+
+  const evaluations = controller.evaluateEvent({ event, resources });
+
+  assert.equal(evaluations.length, 1);
+  assert.equal(evaluations[0].matches, true);
+  assert.equal(evaluations[0].isDuplicate, true);
+});
+
+// 7. processEvent: dispatches matching rules
+test('processEvent: dispatches matching rules via dispatch controller', async () => {
+  let dispatchCalled = false;
+  const mockDispatchController = {
+    async createManualDispatch(input) {
+      dispatchCalled = true;
+      const run = createResource('AgentDispatchRun', { name: `dispatch-${Date.now()}`, namespace: input.namespace }, {
+        organizationRef: input.organizationRef,
+        repository: input.repository,
+        sourceRefs: input.sourceRefs,
+        agentStack: input.agentStack,
+        taskKind: input.taskKind
+      });
+      run.status = { phase: 'Queued' };
+      return { error: false, run };
+    }
+  };
+  const controller = createAgentTriggerController({ dispatchController: mockDispatchController });
+  const rule = makeTriggerRule('rule-dispatch');
+  const event = makeEvent();
+  const resources = { AgentTriggerRule: [rule], AgentTriggerExecution: [] };
+
+  const result = await controller.processEvent({ event, resources, namespace: 'krate-org-default', organizationRef: 'default' });
+
+  assert.equal(dispatchCalled, true, 'Dispatch controller should be called');
+  assert.equal(result.dispatched, 1);
+  assert.equal(result.skipped, 0);
+  assert.equal(result.processed, 1);
+  assert.equal(result.executions.length, 1);
+  assert.equal(result.executions[0].status.phase, 'Dispatched');
+  assert.ok(result.executions[0].status.dispatchRunRef, 'Execution should reference the dispatch run');
+});
+
+// 8. processEvent: skips non-matching
+test('processEvent: skips non-matching rules', async () => {
+  const controller = createAgentTriggerController();
+  const rule = makeTriggerRule('rule-skip', { sources: ['ci-failure'] });
+  const event = makeEvent({ type: 'webhook' });
+  const resources = { AgentTriggerRule: [rule], AgentTriggerExecution: [] };
+
+  const result = await controller.processEvent({ event, resources });
+
+  assert.equal(result.dispatched, 0);
+  assert.equal(result.skipped, 1);
+  assert.equal(result.processed, 1);
+  assert.equal(result.executions[0].status.phase, 'Skipped');
+});
+
+// 9. processEvent: multiple rules match same event
+test('processEvent: multiple rules match same event', async () => {
+  let dispatchCount = 0;
+  const mockDispatchController = {
+    async createManualDispatch(input) {
+      dispatchCount++;
+      const run = createResource('AgentDispatchRun', { name: `dispatch-${Date.now()}-${dispatchCount}`, namespace: input.namespace }, {
+        organizationRef: input.organizationRef,
+        repository: input.repository,
+        sourceRefs: input.sourceRefs,
+        agentStack: input.agentStack,
+        taskKind: input.taskKind
+      });
+      run.status = { phase: 'Queued' };
+      return { error: false, run };
+    }
+  };
+  const controller = createAgentTriggerController({ dispatchController: mockDispatchController });
+  const rule1 = makeTriggerRule('rule-multi-1', { sources: ['ci-failure'], agentStack: 'stack-a' });
+  const rule2 = makeTriggerRule('rule-multi-2', { sources: ['ci-failure'], agentStack: 'stack-b' });
+  const event = makeEvent();
+  const resources = { AgentTriggerRule: [rule1, rule2], AgentTriggerExecution: [] };
+
+  const result = await controller.processEvent({ event, resources, namespace: 'krate-org-default', organizationRef: 'default' });
+
+  assert.equal(dispatchCount, 2, 'Dispatch should be called twice');
+  assert.equal(result.dispatched, 2);
+  assert.equal(result.skipped, 0);
+  assert.equal(result.processed, 2);
+  assert.equal(result.executions.length, 2);
+});
+
+// 10. processEvent: no rules
+test('processEvent: empty rules array', async () => {
+  const controller = createAgentTriggerController();
+  const event = makeEvent();
+  const resources = { AgentTriggerRule: [], AgentTriggerExecution: [] };
+
+  const result = await controller.processEvent({ event, resources });
+
+  assert.equal(result.processed, 0);
+  assert.equal(result.dispatched, 0);
+  assert.equal(result.skipped, 0);
+  assert.equal(result.executions.length, 0);
+});