@geraldmaron/construct 1.4.1 → 1.5.0

package/lib/providers/contract/adapters/git/index.mjs

@@ -1,115 +0,0 @@
-/**
- * providers/git/index.mjs — git repo provider.
- *
- * Transport: git CLI (via child_process). No external deps.
- *
- * Capabilities: read, search
- *
- * read refs:
- *   "commits"              → recent commits (default 20)
- *   "commits:<n>"          → last n commits
- *   "branches"             → all branch names
- *   "file:<path>"          → file contents at HEAD
- *   "status"               → working tree status
- *   "log:<path>"           → commit log for a specific path
- *
- * search: grep across tracked files (git grep)
- */
-
-import { spawnSync } from 'node:child_process';
-import path from 'node:path';
-import { AuthError, NotFoundError } from '../../errors.mjs';
-
-function git(args, cwd) {
-  const result = spawnSync('git', args, { cwd, encoding: 'utf8' });
-  if (result.error) throw new Error(`git spawn error: ${result.error.message}`);
-  return { stdout: result.stdout ?? '', stderr: result.stderr ?? '', status: result.status };
-}
-
-export default {
-  name: 'git',
-  capabilities: ['read', 'search'],
-
-  _cwd: null,
-
-  async init(config = {}) {
-    const cwd = config.cwd ?? process.cwd();
-    // Verify this is actually a git repo
-    const check = git(['rev-parse', '--git-dir'], cwd);
-    if (check.status !== 0) {
-      throw new AuthError(`Not a git repository: ${cwd}`, { provider: 'git' });
-    }
-    this._cwd = cwd;
-  },
-
-  async read(ref, _opts = {}) {
-    const cwd = this._cwd ?? process.cwd();
-
-    if (ref === 'branches') {
-      const r = git(['branch', '-a', '--format=%(refname:short)'], cwd);
-      return r.stdout.trim().split('\n').filter(Boolean).map((name) => ({ type: 'branch', name }));
-    }
-
-    if (ref === 'status') {
-      const r = git(['status', '--porcelain=v1'], cwd);
-      return r.stdout.trim().split('\n').filter(Boolean).map((line) => ({
-        type: 'status-entry',
-        code: line.slice(0, 2).trim(),
-        path: line.slice(3),
-      }));
-    }
-
-    if (ref.startsWith('commits') || ref === 'commits') {
-      const n = ref.includes(':') ? parseInt(ref.split(':')[1], 10) : 20;
-      const r = git(['log', `--max-count=${n}`, '--pretty=format:%H\t%an\t%ae\t%ai\t%s'], cwd);
-      return r.stdout.trim().split('\n').filter(Boolean).map((line) => {
-        const [hash, author, email, date, ...subjectParts] = line.split('\t');
-        return { type: 'commit', hash, author, email, date, subject: subjectParts.join('\t') };
-      });
-    }
-
-    if (ref.startsWith('file:')) {
-      const filePath = ref.slice(5);
-      const r = git(['show', `HEAD:${filePath}`], cwd);
-      if (r.status !== 0) {
-        throw new NotFoundError(`File not found in HEAD: ${filePath}`, { provider: 'git' });
-      }
-      return [{ type: 'file', path: filePath, content: r.stdout }];
-    }
-
-    if (ref.startsWith('log:')) {
-      const filePath = ref.slice(4);
-      const r = git(['log', '--follow', '--pretty=format:%H\t%an\t%ai\t%s', '--', filePath], cwd);
-      return r.stdout.trim().split('\n').filter(Boolean).map((line) => {
-        const [hash, author, date, ...subjectParts] = line.split('\t');
-        return { type: 'commit', hash, author, date, subject: subjectParts.join('\t'), path: filePath };
-      });
-    }
-
-    throw new NotFoundError(`Unknown git read ref: "${ref}"`, { provider: 'git' });
-  },
-
-  async search(query, opts = {}) {
-    const cwd = this._cwd ?? process.cwd();
-    const args = ['grep', '--line-number', '-I'];
-    if (opts.ignoreCase) args.push('-i');
-    args.push(query);
-    if (opts.paths) args.push('--', ...opts.paths);
-    const r = git(args, cwd);
-    if (r.status === 1 && r.stdout === '') return []; // no matches
-    if (r.status !== 0 && r.status !== 1) {
-      throw new Error(`git grep failed: ${r.stderr}`);
-    }
-    return r.stdout.trim().split('\n').filter(Boolean).map((line) => {
-      const colonIdx = line.indexOf(':');
-      const rest = line.slice(colonIdx + 1);
-      const lineNumIdx = rest.indexOf(':');
-      return {
-        type: 'grep-match',
-        file: line.slice(0, colonIdx),
-        lineNumber: parseInt(rest.slice(0, lineNumIdx), 10),
-        text: rest.slice(lineNumIdx + 1),
-      };
-    });
-  },
-};

package/lib/providers/contract/adapters/slack/index.mjs

@@ -1,175 +0,0 @@
-/**
- * providers/slack/index.mjs — Slack provider.
- *
- * Transport: Slack Web API (direct fetch, no SDK).
- * Auth: Bot token via SLACK_BOT_TOKEN env var, or config.token.
- *
- * Capabilities: read, write, watch
- *
- * read refs:
- *   "channels"                     → list of public channels the bot is in
- *   "channel:<id>:messages"        → recent messages in a channel (default 20)
- *   "channel:<id>:messages:<n>"    → last n messages
- *   "thread:<channel>:<ts>"        → thread replies
- *   "user:<id>"                    → user profile
- *
- * write items:
- *   { type: 'message', channel, text, thread_ts? }   → post a message
- *   { type: 'reaction', channel, timestamp, emoji }  → add a reaction
- *
- * watch: poll a channel for new messages since last seen timestamp
- *   watch({ channel, since? }, callback) → returns unsubscribe fn
- */
-
-import { AuthError, NotFoundError, RateLimitError } from '../../errors.mjs';
-
-const SLACK_API = 'https://slack.com/api';
-
-export default {
-  name: 'slack',
-  capabilities: ['read', 'write', 'watch'],
-
-  _token: null,
-  _pollIntervals: new Map(),
-
-  async init(config = {}) {
-    const token = config.token ?? process.env.SLACK_BOT_TOKEN;
-    if (!token) {
-      throw new AuthError(
-        'Slack provider requires SLACK_BOT_TOKEN or config.token',
-        { provider: 'slack' },
-      );
-    }
-    this._token = token;
-    const res = await this._call('auth.test', {});
-    if (!res.ok) {
-      throw new AuthError(`Slack auth failed: ${res.error}`, { provider: 'slack' });
-    }
-  },
-
-  async _call(method, params) {
-    const url = `${SLACK_API}/${method}`;
-    const res = await fetch(url, {
-      method: 'POST',
-      headers: {
-        Authorization: `Bearer ${this._token}`,
-        'Content-Type': 'application/json; charset=utf-8',
-      },
-      body: JSON.stringify(params),
-    });
-    if (res.status === 429) {
-      const retryAfter = parseInt(res.headers.get('Retry-After') ?? '30', 10);
-      throw new RateLimitError('Slack rate limit hit', { provider: 'slack', retryAfter });
-    }
-    return res.json();
-  },
-
-  async read(ref, _opts = {}) {
-    if (ref === 'channels') {
-      const data = await this._call('conversations.list', { types: 'public_channel,private_channel', limit: 200 });
-      if (!data.ok) throw new Error(`Slack error: ${data.error}`);
-      return (data.channels ?? []).map((c) => ({
-        type: 'channel',
-        id: c.id,
-        name: c.name,
-        isPrivate: c.is_private,
-        memberCount: c.num_members,
-      }));
-    }
-
-    const channelMsgMatch = ref.match(/^channel:([^:]+):messages(?::(\d+))?$/);
-    if (channelMsgMatch) {
-      const channel = channelMsgMatch[1];
-      const limit = parseInt(channelMsgMatch[2] ?? '20', 10);
-      const data = await this._call('conversations.history', { channel, limit });
-      if (!data.ok) {
-        if (data.error === 'channel_not_found') throw new NotFoundError(`Channel not found: ${channel}`, { provider: 'slack' });
-        throw new Error(`Slack error: ${data.error}`);
-      }
-      return (data.messages ?? []).map(normalizeMessage);
-    }
-
-    const threadMatch = ref.match(/^thread:([^:]+):(.+)$/);
-    if (threadMatch) {
-      const [, channel, ts] = threadMatch;
-      const data = await this._call('conversations.replies', { channel, ts });
-      if (!data.ok) throw new Error(`Slack error: ${data.error}`);
-      return (data.messages ?? []).map(normalizeMessage);
-    }
-
-    if (ref.startsWith('user:')) {
-      const userId = ref.slice(5);
-      const data = await this._call('users.info', { user: userId });
-      if (!data.ok) {
-        if (data.error === 'user_not_found') throw new NotFoundError(`User not found: ${userId}`, { provider: 'slack' });
-        throw new Error(`Slack error: ${data.error}`);
-      }
-      const u = data.user;
-      return [{ type: 'user', id: u.id, name: u.name, realName: u.real_name, email: u.profile?.email }];
-    }
-
-    throw new NotFoundError(`Unknown Slack read ref: "${ref}"`, { provider: 'slack' });
-  },
-
-  async write(item) {
-    if (item.type === 'message') {
-      const params = { channel: item.channel, text: item.text };
-      if (item.thread_ts) params.thread_ts = item.thread_ts;
-      if (item.blocks) params.blocks = item.blocks;
-      const data = await this._call('chat.postMessage', params);
-      if (!data.ok) throw new Error(`Slack error: ${data.error}`);
-      return { type: 'message-posted', ts: data.ts, channel: data.channel };
-    }
-
-    if (item.type === 'reaction') {
-      const data = await this._call('reactions.add', {
-        channel: item.channel,
-        timestamp: item.timestamp,
-        name: item.emoji,
-      });
-      if (!data.ok && data.error !== 'already_reacted') throw new Error(`Slack error: ${data.error}`);
-      return { type: 'reaction-added', emoji: item.emoji };
-    }
-
-    throw new Error(`Unknown Slack write item type: "${item.type}"`);
-  },
-
-  watch(filter, callback) {
-    const channel = filter.channel;
-    let since = filter.since ?? String(Date.now() / 1000 - 60);
-    const intervalMs = filter.intervalMs ?? 15000;
-
-    const id = setInterval(async () => {
-      try {
-        const data = await this._call('conversations.history', {
-          channel,
-          oldest: since,
-          limit: 50,
-        });
-        if (!data.ok) return;
-        const messages = (data.messages ?? []).filter((m) => m.ts > since);
-        if (messages.length) {
-          since = messages[0].ts; // Slack returns newest first
-          for (const msg of messages.reverse()) callback(normalizeMessage(msg));
-        }
-      } catch { /* swallow poll errors — network blip shouldn't kill the watcher */ }
-    }, intervalMs);
-
-    this._pollIntervals.set(id, true);
-    return () => {
-      clearInterval(id);
-      this._pollIntervals.delete(id);
-    };
-  },
-};
-
-function normalizeMessage(m) {
-  return {
-    type: 'message',
-    ts: m.ts,
-    user: m.user ?? m.bot_id,
-    text: m.text,
-    threadTs: m.thread_ts ?? null,
-    replyCount: m.reply_count ?? 0,
-  };
-}

package/specialists/org/contracts/business-strategist-to-product-manager.json

@@ -1,39 +0,0 @@
-{
-  "id": "business-strategist-to-product-manager",
-  "producer": "cx-business-strategist",
-  "consumer": "cx-product-manager",
-  "trigger": {
-    "strategy.required": true
-  },
-  "input": {
-    "shape": "strategic-memo",
-    "mustContain": [
-      "strategicContext",
-      "recommendation",
-      "evidence"
-    ]
-  },
-  "output": {
-    "shape": "prd-handoff",
-    "mustContain": [
-      "problem",
-      "users",
-      "functionalRequirements",
-      "acceptanceCriteria"
-    ]
-  },
-  "preconditions": [
-    "Strategic memo signed off; recommended option carried into PRD framing"
-  ],
-  "postconditions": [
-    "PRD Problem statement traces to the strategic memo's market context, not to internal roadmap items",
-    "PRD acknowledges the competitive dynamic named in the strategic memo"
-  ],
-  "description": "",
-  "teamBoundary": {
-    "crosses": true,
-    "producerTeam": "strategy-group",
-    "consumerTeam": "product-group",
-    "requiresApprovalFrom": []
-  }
-}

package/specialists/org/contracts/construct-to-rd-lead.json

@@ -1,53 +0,0 @@
-{
-  "id": "construct-to-rd-lead",
-  "producer": "construct",
-  "consumer": "cx-rd-lead",
-  "trigger": {
-    "framingChallenge.required": true
-  },
-  "input": {
-    "shape": "framing-request",
-    "mustContain": [
-      "goal",
-      "uncertainty",
-      "assumptions"
-    ]
-  },
-  "output": {
-    "shape": "framing-brief",
-    "mustContain": [
-      "problemStatement",
-      "hypothesis",
-      "keyUnknowns",
-      "evidenceThreshold",
-      "recommendation"
-    ]
-  },
-  "preconditions": [
-    "Framing gate fires before architecture work begins",
-    "Strategy bets and non-bets reviewed in `.cx/knowledge/decisions/strategy/`"
-  ],
-  "postconditions": [
-    "Hypothesis is falsifiable and stated as 'We believe [X] will result in [Y] because [Z].'",
-    "Evidence threshold names a specific result that would confirm or disconfirm",
-    {
-      "id": "rd-framing-has-problem-section",
-      "description": "Framing artifact must contain a Problem section",
-      "check": "artifact-has-section",
-      "section": "Problem"
-    },
-    {
-      "id": "rd-framing-has-constraints-section",
-      "description": "Framing artifact must contain a Constraints section",
-      "check": "artifact-has-section",
-      "section": "Constraints"
-    },
-    {
-      "id": "rd-framing-has-open-questions-section",
-      "description": "Framing artifact must contain an Open Questions section",
-      "check": "artifact-has-section",
-      "section": "Open Questions"
-    }
-  ],
-  "description": ""
-}

package/specialists/org/contracts/data-engineer-to-platform-engineer.json

@@ -1,36 +0,0 @@
-{
-  "id": "data-engineer-to-platform-engineer",
-  "producer": "cx-data-engineer",
-  "consumer": "cx-platform-engineer",
-  "trigger": {
-    "riskFlags": [
-      "data",
-      "pipeline",
-      "infrastructure"
-    ]
-  },
-  "input": {
-    "shape": "pipeline-spec",
-    "mustContain": [
-      "dataContract",
-      "qualityGates"
-    ]
-  },
-  "output": {
-    "shape": "platform-plan",
-    "mustContain": [
-      "problem",
-      "solution",
-      "migration",
-      "rollback"
-    ]
-  },
-  "preconditions": [
-    "Pipeline operational requirements (alerts, retries, backfills) stated in pipeline spec"
-  ],
-  "postconditions": [
-    "Operational burden (who maintains, how to debug) accepted by platform owner",
-    "Pipeline observability surfaces appear on a named dashboard, not just in logs"
-  ],
-  "description": ""
-}

package/specialists/org/contracts/designer-to-accessibility.json

@@ -1,36 +0,0 @@
-{
-  "id": "designer-to-accessibility",
-  "producer": "cx-designer",
-  "consumer": "cx-accessibility",
-  "trigger": {
-    "riskFlags": [
-      "ui",
-      "accessibility"
-    ]
-  },
-  "input": {
-    "shape": "design-deliverable",
-    "mustContain": [
-      "surface",
-      "deliverable",
-      "accessibilityCheckRan"
-    ]
-  },
-  "output": {
-    "shape": "a11y-findings",
-    "mustContain": [
-      "findings",
-      "wcagCriterion",
-      "userImpact",
-      "fix"
-    ]
-  },
-  "preconditions": [
-    "Flow exercised with a keyboard and a screen reader; not just spec-read"
-  ],
-  "postconditions": [
-    "Every finding cites a WCAG criterion and a concrete repro step",
-    "Findings that weren't exercised with the assistive technology are labeled 'unverified'"
-  ],
-  "description": ""
-}

package/specialists/org/contracts/platform-engineer-to-engineer.json

@@ -1,31 +0,0 @@
-{
-  "id": "platform-engineer-to-engineer",
-  "producer": "cx-platform-engineer",
-  "consumer": "cx-engineer",
-  "trigger": {
-    "riskFlags": [
-      "platform"
-    ]
-  },
-  "input": {
-    "shape": "platform-plan",
-    "mustContain": [
-      "solution",
-      "migration",
-      "rollback"
-    ]
-  },
-  "output": {
-    "schema": "lib/contract-schemas/implementation.json",
-    "type": "implementation"
-  },
-  "preconditions": [
-    "Platform deps available in CI; lockfile updates reviewed",
-    "Secrets confirmed absent from build logs"
-  ],
-  "postconditions": [
-    "Implementation cites the platform plan and applies the migration steps in order",
-    "Rollback procedure verified once on a non-production environment"
-  ],
-  "description": ""
-}

package/specialists/org/contracts/qa-to-test-automation.json

@@ -1,42 +0,0 @@
-{
-  "id": "qa-to-test-automation",
-  "producer": "cx-qa",
-  "consumer": "cx-test-automation",
-  "trigger": {
-    "intent": [
-      "implementation"
-    ],
-    "automation.required": true
-  },
-  "input": {
-    "schema": "lib/contract-schemas/test-report.json",
-    "mustContain": [
-      "testStrategy",
-      "verdict"
-    ]
-  },
-  "output": {
-    "shape": "automation-plan",
-    "mustContain": [
-      "framework",
-      "coverageTargets",
-      "flakeBudget",
-      "deterministicWaits"
-    ]
-  },
-  "preconditions": [
-    "Existing test infrastructure surveyed before proposing new frameworks",
-    "Flaky-test signal collected over N runs before calling a test flaky"
-  ],
-  "postconditions": [
-    "Tests use deterministic waits and stable selectors; not arbitrary sleeps",
-    "Coverage targets aim at behaviors that matter, not at line counts that pad the number",
-    {
-      "id": "automation-plan-has-flake-budget",
-      "description": "Automation plan must contain a Flake Budget section",
-      "check": "artifact-has-section",
-      "section": "Flake Budget"
-    }
-  ],
-  "description": ""
-}

package/specialists/org/contracts/rd-lead-to-architect.json

@@ -1,38 +0,0 @@
-{
-  "id": "rd-lead-to-architect",
-  "producer": "cx-rd-lead",
-  "consumer": "cx-architect",
-  "trigger": {
-    "framingChallenge.required": true,
-    "rdLead.verdict": "frame-approved"
-  },
-  "input": {
-    "shape": "framing-brief",
-    "mustContain": [
-      "problemStatement",
-      "hypothesis",
-      "keyUnknowns",
-      "evidenceThreshold",
-      "recommendation"
-    ]
-  },
-  "output": {
-    "schema": "lib/contract-schemas/decision.json",
-    "type": "decision"
-  },
-  "preconditions": [
-    "Framing artifact exists at `.cx/framing/<slug>.md`",
-    "Hypothesis cleared of unverified assumptions"
-  ],
-  "postconditions": [
-    "ADR cites the framing brief as the upstream source for its Problem statement",
-    "Architect does not productionize components listed under 'WHAT NOT TO PRODUCTIONIZE YET'"
-  ],
-  "description": "",
-  "teamBoundary": {
-    "crosses": true,
-    "producerTeam": "strategy-group",
-    "consumerTeam": "engineering-group",
-    "requiresApprovalFrom": []
-  }
-}

package/specialists/org/contracts/sre-to-release-manager.json

@@ -1,36 +0,0 @@
-{
-  "id": "sre-to-release-manager",
-  "producer": "cx-sre",
-  "consumer": "cx-release-manager",
-  "trigger": {
-    "riskFlags": [
-      "dataIntegrity"
-    ],
-    "intent": [
-      "implementation"
-    ]
-  },
-  "input": {
-    "shape": "sre-readiness",
-    "mustContain": [
-      "slos",
-      "runbooks",
-      "alerts",
-      "dashboards"
-    ]
-  },
-  "output": {
-    "shape": "release-decision",
-    "mustContain": [
-      "decision",
-      "rollbackPlan"
-    ]
-  },
-  "preconditions": [
-    "Runbook exists for the new code path; rollback procedure verified"
-  ],
-  "postconditions": [
-    "On-call briefed; alert thresholds set"
-  ],
-  "description": ""
-}

package/specialists/org/specialists/cx-accessibility.json

@@ -1,69 +0,0 @@
-{
-  "name": "accessibility",
-  "displayName": "Tests with a screen reader and keyboard — accessibility is measured by using the product, not reading the spec.",
-  "description": "Tests with a screen reader and keyboard — accessibility is measured by using the product, not reading the spec.",
-  "role": "accessibility",
-  "modelTier": "standard",
-  "reasoningEffort": "medium",
-  "skills": [
-    "frontend-design/accessibility",
-    "frontend-design/screen-reader-testing"
-  ],
-  "events": [
-    "a11y.violation"
-  ],
-  "fence": {
-    "allowedPaths": [
-      "docs/accessibility/**",
-      "docs/a11y/**"
-    ],
-    "allowedBdLabels": [
-      "accessibility",
-      "a11y"
-    ],
-    "allowedCommands": [
-      "bd create",
-      "bd note",
-      "bd update",
-      "bd label"
-    ],
-    "approvalRequired": [
-      "commit",
-      "push",
-      "edit:**"
-    ]
-  },
-  "docArtifacts": [],
-  "watchConditions": [],
-  "permissions": {},
-  "promptFile": "specialists/prompts/cx-accessibility.md",
-  "embedOrientation": {
-    "focusAreas": [
-      "keyboard navigability",
-      "screen reader compatibility",
-      "contrast compliance",
-      "ARIA correctness"
-    ],
-    "riskSignals": [
-      "ARIA added without testing",
-      "keyboard traps",
-      "contrast failures",
-      "missing focus indicators"
-    ],
-    "artifactBias": [
-      "notes"
-    ]
-  },
-  "canEdit": false,
-  "claudeTools": "Read,Grep,Glob,LS,Bash,list_skills,get_skill,search_skills,memory_search,memory_add_observations,get_template,list_templates",
-  "internal": true,
-  "killSwitchEnv": "CONSTRUCT_ROLE_ACCESSIBILITY",
-  "handoffCandidates": [
-    "engineer",
-    "designer",
-    "qa"
-  ],
-  "team": "accessibility-team",
-  "teamId": "accessibility-team",
-  "groupId": "product-group"
-}