@tekyzinc/gsd-t 3.23.11 → 3.25.10

package/bin/gsd-t-context-brief-kinds/execute.cjs

@@ -0,0 +1,205 @@
+'use strict';
+
+/**
+ * execute kind collector — pulls domain scope/constraints/tasks/contracts
+ * for a single domain so an execute-phase worker can grep the brief
+ * instead of re-walking the repo.
+ *
+ * Fail-open: if the domain dir is missing, scope/constraints/contracts
+ * are empty arrays — the brief is still written.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const NAME = 'execute';
+
+function _readMaybe(file) {
+  try { return fs.readFileSync(file, 'utf8'); } catch (_) { return null; }
+}
+
+/**
+ * Extract bullet items under a `## Heading` (non-greedy, until the next `## ` or EOF).
+ */
+function _bulletsUnderSection(text, headingPattern) {
+  if (!text) return [];
+  // Locate `## <heading>` line; capture body until next `## ` or end-of-string.
+  // (JS regex has no `\Z`; use the m-flag $ + a non-greedy lookahead, then
+  // trim the tail at the next H2.)
+  const re = new RegExp('^##\\s+' + headingPattern + '\\s*$', 'mi');
+  const m = text.match(re);
+  if (!m) return [];
+  const start = m.index + m[0].length;
+  const remainder = text.slice(start);
+  const next = remainder.match(/^##\s+/m);
+  const body = next ? remainder.slice(0, next.index) : remainder;
+  const out = [];
+  for (const line of body.split(/\r?\n/)) {
+    // Only top-level bullets (no leading whitespace) — sub-bullets belong to
+    // their parent and would inflate the brief size.
+    const bm = line.match(/^[-*]\s+(.+)$/);
+    if (!bm) continue;
+    let item = bm[1].replace(/`/g, '').replace(/\*\*/g, '').trim();
+    if (!item) continue;
+    if (item.length > 240) item = item.slice(0, 237) + '...';
+    out.push(item);
+  }
+  return out;
+}
+
+/**
+ * Extract a path glob list from "Owned Files/Directories" section bullets,
+ * keeping only the leading code-fence path before any em-dash.
+ */
+function _sectionBody(text, headingRe) {
+  if (!text) return '';
+  const m = text.match(headingRe);
+  if (!m) return '';
+  const start = m.index + m[0].length;
+  const remainder = text.slice(start);
+  const next = remainder.match(/^##\s+/m);
+  return next ? remainder.slice(0, next.index) : remainder;
+}
+
+function _ownedPathsFromScope(text) {
+  const body = _sectionBody(text, /^##\s+Owned Files\/Directories\s*$/mi);
+  if (!body) return [];
+  const out = [];
+  for (const line of body.split(/\r?\n/)) {
+    // Top-level only — captures `- ` `path``... but skips ` - sub.cjs ...` two-space-indent sub-bullets.
+    const bm = line.match(/^[-*]\s+`([^`]+)`/);
+    if (bm) out.push(bm[1]);
+  }
+  return out;
+}
+
+function _notOwnedPaths(text) {
+  const body = _sectionBody(text, /^##\s+NOT Owned[^\n]*$/mi);
+  if (!body) return [];
+  const out = [];
+  for (const line of body.split(/\r?\n/)) {
+    const bm = line.match(/^[-*]\s+`([^`]+)`/);
+    if (bm) out.push(bm[1]);
+  }
+  return out;
+}
+
+/**
+ * Collect contract paths referenced from inside the scope text — pattern
+ * `.gsd-t/contracts/<name>.md`.
+ */
+function _contractsReferenced(text, projectDir) {
+  if (!text) return [];
+  const re = /\.gsd-t\/contracts\/[a-zA-Z0-9_./-]+\.md/g;
+  const seen = new Set();
+  const out = [];
+  let m;
+  while ((m = re.exec(text)) != null) {
+    const p = m[0];
+    if (seen.has(p)) continue;
+    seen.add(p);
+    let status = 'UNKNOWN';
+    const full = path.join(projectDir, p);
+    try {
+      const c = fs.readFileSync(full, 'utf8');
+      const sm = c.match(/Status:\s*\**\s*(STABLE|DRAFT|PROPOSED)/i);
+      if (sm) status = sm[1].toUpperCase();
+    } catch (_) { /* fail-open */ }
+    out.push({ path: p, status });
+  }
+  return out;
+}
+
+/**
+ * Extract the task ids ("T1", "T-2", "M55-D4-T3", …) from tasks.md.
+ */
+function _tasksFromTasksMd(text) {
+  if (!text) return [];
+  const out = [];
+  const seen = new Set();
+  function push(id) { if (!seen.has(id)) { seen.add(id); out.push(id); } }
+
+  // ##/### M{NN}-D{N}-T{N} (Shape C heading) — try BEFORE the bare-T regex so
+  // the M-prefixed id wins.
+  const reC = /^#{2,3}\s+(M\d+-D\d+-T\d+)\b[^\n]*$/gm;
+  let m;
+  while ((m = reC.exec(text)) != null) push(m[1]);
+
+  // ## T1 — heading (Shape A — bare T-id)
+  const reH = /^##\s+(T-?\d+)\b[^\n]*$/gm;
+  while ((m = reH.exec(text)) != null) push(m[1]);
+
+  // - [ ] **M55-D4-T1** (Shape C bullets)
+  const reBC = /^\s*-\s*\[[ x]\]\s+\*\*(M\d+-D\d+-T\d+)\*\*/gm;
+  while ((m = reBC.exec(text)) != null) push(m[1]);
+
+  return out;
+}
+
+function collect(ctx) {
+  const { projectDir, domain, recordSource } = ctx;
+  const ancillary = {
+    expectedOutputs: [],
+    filesOwned: [],
+    notOwned: [],
+    tasks: [],
+  };
+  let scope = { owned: [], notOwned: [], deliverables: [] };
+  let constraints = [];
+  let contracts = [];
+
+  if (!domain) {
+    return { scope, constraints, contracts, ancillary };
+  }
+
+  const dir = path.join(projectDir, '.gsd-t', 'domains', domain);
+  if (!fs.existsSync(dir)) {
+    // Fail-open: domain dir absent → empty fields.
+    return { scope, constraints, contracts, ancillary };
+  }
+
+  const scopePath = '.gsd-t/domains/' + domain + '/scope.md';
+  const constraintsPath = '.gsd-t/domains/' + domain + '/constraints.md';
+  const tasksPath = '.gsd-t/domains/' + domain + '/tasks.md';
+
+  const scopeText = _readMaybe(path.join(projectDir, scopePath));
+  if (scopeText) recordSource(scopePath);
+  const constraintsText = _readMaybe(path.join(projectDir, constraintsPath));
+  if (constraintsText) recordSource(constraintsPath);
+  const tasksText = _readMaybe(path.join(projectDir, tasksPath));
+  if (tasksText) recordSource(tasksPath);
+
+  const owned = _ownedPathsFromScope(scopeText);
+  const notOwned = _notOwnedPaths(scopeText);
+  const deliverables = _bulletsUnderSection(scopeText, 'Deliverables');
+
+  scope = { owned, notOwned, deliverables };
+
+  const mustFollow = _bulletsUnderSection(constraintsText, 'Must Follow');
+  const mustNot = _bulletsUnderSection(constraintsText, 'Must Not');
+  // Mark items by prefix so the worker can tell them apart.
+  constraints = mustFollow.map((c) => 'MUST: ' + c).concat(mustNot.map((c) => 'MUST NOT: ' + c));
+
+  contracts = _contractsReferenced(scopeText, projectDir);
+
+  const tasks = _tasksFromTasksMd(tasksText);
+
+  ancillary.filesOwned = owned;
+  ancillary.notOwned = notOwned;
+  ancillary.expectedOutputs = deliverables;
+  ancillary.tasks = tasks;
+
+  return { scope, constraints, contracts, ancillary };
+}
+
+module.exports = {
+  name: NAME,
+  requiresSources: [],
+  collect,
+  // Test-only exports
+  _bulletsUnderSection,
+  _ownedPathsFromScope,
+  _notOwnedPaths,
+  _contractsReferenced,
+  _tasksFromTasksMd,
+};

package/bin/gsd-t-context-brief-kinds/qa.cjs

@@ -0,0 +1,130 @@
+'use strict';
+
+/**
+ * qa kind collector — points the QA subagent at its protocol path,
+ * detects the project test runner, and surfaces the most recent
+ * qa-issues entries.
+ *
+ * Fail-CLOSED: requires `templates/prompts/qa-subagent.md`. Library
+ * enforces this via the `requiresSources` declaration.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const NAME = 'qa';
+const PROTOCOL = 'templates/prompts/qa-subagent.md';
+const QA_ISSUES = '.gsd-t/qa-issues.md';
+const TAIL_LIMIT = 10;
+
+function _readMaybe(file) {
+  try { return fs.readFileSync(file, 'utf8'); } catch (_) { return null; }
+}
+
+function _detectTestRunner(projectDir) {
+  const detected = {
+    npmTest: null,
+    playwrightConfig: null,
+    cypressConfig: null,
+    jestConfig: null,
+    vitestConfig: null,
+  };
+
+  const pkgPath = path.join(projectDir, 'package.json');
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    if (pkg && pkg.scripts && typeof pkg.scripts.test === 'string') {
+      detected.npmTest = pkg.scripts.test;
+    }
+  } catch (_) { /* fail-open */ }
+
+  for (const f of ['playwright.config.ts', 'playwright.config.js', 'playwright.config.cjs', 'playwright.config.mjs']) {
+    if (fs.existsSync(path.join(projectDir, f))) { detected.playwrightConfig = f; break; }
+  }
+  for (const f of ['cypress.config.ts', 'cypress.config.js', 'cypress.config.cjs']) {
+    if (fs.existsSync(path.join(projectDir, f))) { detected.cypressConfig = f; break; }
+  }
+  for (const f of ['jest.config.ts', 'jest.config.js', 'jest.config.cjs']) {
+    if (fs.existsSync(path.join(projectDir, f))) { detected.jestConfig = f; break; }
+  }
+  for (const f of ['vitest.config.ts', 'vitest.config.js', 'vitest.config.cjs', 'vitest.config.mjs']) {
+    if (fs.existsSync(path.join(projectDir, f))) { detected.vitestConfig = f; break; }
+  }
+
+  return detected;
+}
+
+function _tailQaIssues(text) {
+  if (!text) return [];
+  const lines = text.split(/\r?\n/);
+  // qa-issues.md is generally a markdown table; keep last N table rows
+  // (rows beginning with `|` and not separator-only).
+  const rows = lines.filter((l) => /^\|/.test(l) && !/^\|\s*-+\s*\|/.test(l));
+  // Drop header (first row), then keep tail.
+  const body = rows.slice(1);
+  const tail = body.slice(-TAIL_LIMIT).map((l) => {
+    const t = l.trim();
+    return t.length > 200 ? t.slice(0, 197) + '...' : t;
+  });
+  return tail;
+}
+
+function _scanContracts(projectDir) {
+  // Pure scan; caller decides which subset to record as sources.
+  const dir = path.join(projectDir, '.gsd-t', 'contracts');
+  let entries;
+  try { entries = fs.readdirSync(dir); } catch (_) { return []; }
+  const out = [];
+  for (const f of entries) {
+    if (!f.endsWith('.md')) continue;
+    const rel = '.gsd-t/contracts/' + f;
+    const text = _readMaybe(path.join(projectDir, rel));
+    if (!text) continue;
+    const m = text.match(/Status:\s*\**\s*(STABLE|DRAFT|PROPOSED)/i);
+    out.push({ path: rel, status: m ? m[1].toUpperCase() : 'UNKNOWN' });
+  }
+  out.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+  return out;
+}
+
+function collect(ctx) {
+  const { projectDir, recordSource } = ctx;
+
+  recordSource(PROTOCOL);
+  recordSource('package.json');
+
+  const issuesText = _readMaybe(path.join(projectDir, QA_ISSUES));
+  if (issuesText != null) recordSource(QA_ISSUES);
+
+  const runner = _detectTestRunner(projectDir);
+  const recentIssues = _tailQaIssues(issuesText);
+  const allContracts = _scanContracts(projectDir);
+  // Only DRAFT / PROPOSED contracts are surfaced individually — QA's job is
+  // to verify implementations match contracts, but a 65-contract list would
+  // bust the 10 KB cap. STABLE / UNKNOWN are counted, not enumerated.
+  const enumerated = allContracts.filter((c) => c.status === 'DRAFT' || c.status === 'PROPOSED');
+  for (const c of enumerated) recordSource(c.path);
+  const counts = { STABLE: 0, DRAFT: 0, PROPOSED: 0, UNKNOWN: 0 };
+  for (const c of allContracts) counts[c.status] = (counts[c.status] || 0) + 1;
+
+  return {
+    scope: { owned: [], notOwned: [], deliverables: [] },
+    constraints: [],
+    contracts: enumerated,
+    ancillary: {
+      contractCount: allContracts.length,
+      contractStatusCounts: counts,
+      protocolPath: PROTOCOL,
+      qaIssuesTail: recentIssues,
+      testRunner: runner,
+    },
+  };
+}
+
+module.exports = {
+  name: NAME,
+  requiresSources: [PROTOCOL],
+  collect,
+  _detectTestRunner,
+  _tailQaIssues,
+};

package/bin/gsd-t-context-brief-kinds/red-team.cjs

@@ -0,0 +1,131 @@
+'use strict';
+
+/**
+ * red-team kind collector — points the Red Team subagent at its protocol,
+ * surfaces the recent commits in scope, and seeds attack vector hints
+ * extracted from the protocol's "broken patches" section.
+ *
+ * Fail-CLOSED: requires `templates/prompts/red-team-subagent.md`. Library
+ * enforces this via the `requiresSources` declaration.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const NAME = 'red-team';
+const PROTOCOL = 'templates/prompts/red-team-subagent.md';
+const COMMIT_LIMIT = 10;
+
+function _readMaybe(file) {
+  try { return fs.readFileSync(file, 'utf8'); } catch (_) { return null; }
+}
+
+function _recentCommits(projectDir) {
+  try {
+    const stdout = execSync('git log -' + COMMIT_LIMIT + ' --oneline --no-color', {
+      cwd: projectDir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    return String(stdout || '')
+      .split(/\r?\n/)
+      .map((l) => l.trim())
+      .filter(Boolean)
+      .slice(0, COMMIT_LIMIT);
+  } catch (_) {
+    return [];
+  }
+}
+
+/**
+ * Pull attack-vector seeds out of the protocol's "Test Pass-Through" /
+ * "broken patches" section, if present. Falls back to an empty array.
+ *
+ * The protocol enumerates examples in a `- Remove the listener entirely`
+ * style — we extract those bullets verbatim (clipped) so the worker can
+ * read them inline without re-fetching the protocol.
+ */
+function _attackVectorSeeds(protocolText) {
+  if (!protocolText) return [];
+  const out = [];
+  // Match the section that explicitly lists broken-patch examples.
+  // (heading variants: "broken patch", "Test Pass-Through", "Attack Categories")
+  const headings = [
+    /^[#]+[^\n]*broken patches?[^\n]*$/im,
+    /^[#]+[^\n]*Test Pass-Through[^\n]*$/im,
+    /^[#]+\s+Attack Categories[^\n]*$/im,
+  ];
+  for (const h of headings) {
+    const hm = protocolText.match(h);
+    if (!hm) continue;
+    const start = hm.index + hm[0].length;
+    const remainder = protocolText.slice(start);
+    const next = remainder.match(/^[#]+\s+/m);
+    const body = next ? remainder.slice(0, next.index) : remainder;
+    for (const line of body.split(/\r?\n/)) {
+      const bm = line.match(/^\s+[-*]\s+(.+)$/);
+      if (!bm) continue;
+      let item = bm[1].replace(/`/g, '').replace(/\*\*/g, '').trim();
+      if (item.length > 160) item = item.slice(0, 157) + '...';
+      out.push(item);
+      if (out.length >= 8) break;
+    }
+    if (out.length) break;
+  }
+  return out;
+}
+
+function _scanContracts(projectDir) {
+  // Pure scan; caller decides which subset to record as sources.
+  const dir = path.join(projectDir, '.gsd-t', 'contracts');
+  let entries;
+  try { entries = fs.readdirSync(dir); } catch (_) { return []; }
+  const out = [];
+  for (const f of entries) {
+    if (!f.endsWith('.md')) continue;
+    const rel = '.gsd-t/contracts/' + f;
+    const text = _readMaybe(path.join(projectDir, rel));
+    if (!text) continue;
+    const m = text.match(/Status:\s*\**\s*(STABLE|DRAFT|PROPOSED)/i);
+    out.push({ path: rel, status: m ? m[1].toUpperCase() : 'UNKNOWN' });
+  }
+  out.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+  return out;
+}
+
+function collect(ctx) {
+  const { projectDir, recordSource } = ctx;
+
+  recordSource(PROTOCOL);
+
+  const protocolText = _readMaybe(path.join(projectDir, PROTOCOL));
+  const seeds = _attackVectorSeeds(protocolText);
+  const recentCommits = _recentCommits(projectDir);
+  const allContracts = _scanContracts(projectDir);
+  const enumerated = allContracts.filter((c) => c.status === 'DRAFT' || c.status === 'PROPOSED');
+  for (const c of enumerated) recordSource(c.path);
+  const counts = { STABLE: 0, DRAFT: 0, PROPOSED: 0, UNKNOWN: 0 };
+  for (const c of allContracts) counts[c.status] = (counts[c.status] || 0) + 1;
+
+  return {
+    scope: { owned: [], notOwned: [], deliverables: [] },
+    constraints: [],
+    contracts: enumerated,
+    ancillary: {
+      attackVectorSeeds: seeds,
+      contractCount: allContracts.length,
+      contractStatusCounts: counts,
+      protocolPath: PROTOCOL,
+      recentCommits,
+    },
+  };
+}
+
+module.exports = {
+  name: NAME,
+  requiresSources: [PROTOCOL],
+  collect,
+  _recentCommits,
+  _attackVectorSeeds,
+};

package/bin/gsd-t-context-brief-kinds/scan.cjs

@@ -0,0 +1,118 @@
+'use strict';
+
+/**
+ * scan kind collector — surfaces a repo-file-inventory hash, the prior
+ * scan output mtime (if any), and the merged exclusion patterns.
+ *
+ * Fail-open: missing optional source → null/empty field, brief still written.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { execSync } = require('child_process');
+
+const NAME = 'scan';
+const PRIOR_SCAN_OUTPUT = '.gsd-t/scan/output.md';
+const SCAN_EXCLUSIONS = '.gsd-t/scan/exclusions.txt';
+const GITIGNORE = '.gitignore';
+
+function _readMaybe(file) {
+  try { return fs.readFileSync(file, 'utf8'); } catch (_) { return null; }
+}
+
+function _gitLsFiles(projectDir) {
+  try {
+    const stdout = execSync('git ls-files', {
+      cwd: projectDir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      maxBuffer: 16 * 1024 * 1024,
+    });
+    return String(stdout || '')
+      .split(/\r?\n/)
+      .map((l) => l.trim())
+      .filter(Boolean);
+  } catch (_) {
+    return [];
+  }
+}
+
+function _hashFileList(files) {
+  const sorted = files.slice().sort();
+  return crypto.createHash('sha256').update(sorted.join('\n')).digest('hex');
+}
+
+/**
+ * Merge `.gitignore` patterns + `.gsd-t/scan/exclusions.txt` (if exists)
+ * into a deduplicated, sorted list. Strips comment + blank lines.
+ */
+function _mergedExclusions(projectDir, recordSource) {
+  const out = new Set();
+  const giText = _readMaybe(path.join(projectDir, GITIGNORE));
+  if (giText != null) {
+    recordSource(GITIGNORE);
+    for (const l of giText.split(/\r?\n/)) {
+      const t = l.trim();
+      if (!t || t.startsWith('#')) continue;
+      out.add(t);
+    }
+  }
+  const seText = _readMaybe(path.join(projectDir, SCAN_EXCLUSIONS));
+  if (seText != null) {
+    recordSource(SCAN_EXCLUSIONS);
+    for (const l of seText.split(/\r?\n/)) {
+      const t = l.trim();
+      if (!t || t.startsWith('#')) continue;
+      out.add(t);
+    }
+  }
+  const arr = Array.from(out);
+  arr.sort();
+  return arr;
+}
+
+function _priorScanMtime(projectDir, recordSource) {
+  const full = path.join(projectDir, PRIOR_SCAN_OUTPUT);
+  if (!fs.existsSync(full)) return null;
+  recordSource(PRIOR_SCAN_OUTPUT);
+  try {
+    const stat = fs.statSync(full);
+    return new Date(stat.mtimeMs).toISOString();
+  } catch (_) {
+    return null;
+  }
+}
+
+function collect(ctx) {
+  const { projectDir, recordSource } = ctx;
+
+  const files = _gitLsFiles(projectDir);
+  const inventoryHash = files.length ? _hashFileList(files) : null;
+  const inventoryCount = files.length;
+
+  const exclusions = _mergedExclusions(projectDir, recordSource);
+  const priorScanMtime = _priorScanMtime(projectDir, recordSource);
+
+  return {
+    scope: { owned: [], notOwned: [], deliverables: [] },
+    constraints: [],
+    contracts: [],
+    ancillary: {
+      exclusions,
+      inventoryCount,
+      inventoryHash,
+      priorScanMtime,
+      priorScanPath: priorScanMtime ? PRIOR_SCAN_OUTPUT : null,
+    },
+  };
+}
+
+module.exports = {
+  name: NAME,
+  requiresSources: [],
+  collect,
+  _gitLsFiles,
+  _hashFileList,
+  _mergedExclusions,
+};