create-byan-agent 2.9.4 → 2.9.6

package/install/templates/.githooks/pre-commit

@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+# BYAN pre-commit hook — enforce mantras score >= 80% on staged agent
+# and skill files. Blocks the commit if any file drops below the
+# threshold so the user can't accidentally push non-compliant artefacts.
+#
+# Install :
+#   git config core.hooksPath .githooks
+#
+# Bypass (emergency only) :
+#   git commit --no-verify
+#
+# Scope : only files matching
+#   _byan/bmb/agents/*.md, _byan/agents/*.md,
+#   .github/agents/*.md, .claude/skills/*/SKILL.md,
+#   .claude/agents/*.md
+# are validated. Non-agent files are ignored.
+
+set -euo pipefail
+
+THRESHOLD=80
+VALIDATOR="src/byan-v2/generation/mantra-validator.js"
+
+if ! command -v node >/dev/null 2>&1; then
+  echo "[byan pre-commit] node not found, skipping mantra check"
+  exit 0
+fi
+
+if [ ! -f "$VALIDATOR" ]; then
+  exit 0
+fi
+
+staged=$(git diff --cached --name-only --diff-filter=ACM | grep -E '^(_byan/bmb/agents/.*\.md|_byan/agents/.*\.md|\.github/agents/.*\.md|\.claude/skills/.*SKILL\.md|\.claude/agents/.*\.md)$' || true)
+
+if [ -z "$staged" ]; then
+  exit 0
+fi
+
+failed=0
+while IFS= read -r file; do
+  [ -z "$file" ] && continue
+  [ ! -f "$file" ] && continue
+
+  score=$(node -e "
+    const V = require('./$VALIDATOR');
+    const fs = require('fs');
+    try {
+      const content = fs.readFileSync('$file', 'utf8');
+      const v = new V();
+      const res = v.validate(content);
+      const pct = Math.round((res.compliant.length / res.totalMantras) * 100);
+      process.stdout.write(String(pct));
+    } catch (e) {
+      process.stderr.write(e.message);
+      process.stdout.write('0');
+    }
+  " 2>/dev/null || echo "0")
+
+  if [ -z "$score" ] || [ "$score" = "0" ]; then
+    continue
+  fi
+
+  if [ "$score" -lt "$THRESHOLD" ]; then
+    echo "[byan pre-commit] FAIL $file : mantra score $score% < $THRESHOLD%"
+    failed=1
+  fi
+done <<< "$staged"
+
+if [ "$failed" -eq 1 ]; then
+  echo ""
+  echo "Commit blocked by BYAN mantra pre-commit hook."
+  echo "Fix the flagged files above, or bypass with 'git commit --no-verify' (emergency only)."
+  exit 1
+fi
+
+exit 0

package/install/templates/.github/extensions/byan-staging/extension.mjs

@@ -0,0 +1,169 @@
+/**
+ * Copilot CLI extension — BYAN staging (SM1c).
+ *
+ * Attaches to the current Copilot session via joinSession() and
+ * triggers the BYAN staging pipeline at the end of each assistant
+ * turn. Delegates to src/staging/staging.js so Claude Code and Copilot
+ * CLI share the exact same extract / filter / dedup / queue / flush
+ * logic.
+ *
+ * How it's discovered : Copilot CLI scans .github/extensions/
+ * (project) and the user's copilot config for subdirectories
+ * containing extension.mjs. This file is auto-launched as a child
+ * process, gets @github/copilot-sdk on its module path, and calls
+ * joinSession with the hook registration below.
+ */
+
+import { joinSession } from '@github/copilot-sdk/extension';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import fs from 'node:fs';
+
+const require = createRequire(import.meta.url);
+
+const EXTENSION_DIR = path.dirname(new URL(import.meta.url).pathname);
+const PROJECT_ROOT =
+  process.env.BYAN_PROJECT_ROOT ||
+  process.env.CLAUDE_PROJECT_DIR ||
+  findProjectRoot(EXTENSION_DIR);
+
+function findProjectRoot(startDir) {
+  // Walk up until we find a package.json or .git — else cwd
+  let dir = startDir;
+  for (let i = 0; i < 6; i++) {
+    if (
+      fs.existsSync(path.join(dir, 'package.json')) ||
+      fs.existsSync(path.join(dir, '.git'))
+    ) {
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return process.cwd();
+}
+
+function loadStaging() {
+  try {
+    return require(path.join(PROJECT_ROOT, 'src', 'staging', 'staging.js'));
+  } catch {
+    return null;
+  }
+}
+
+function readSettingsEnv() {
+  const p = path.join(PROJECT_ROOT, '.claude', 'settings.local.json');
+  if (!fs.existsSync(p)) return {};
+  try {
+    const j = JSON.parse(fs.readFileSync(p, 'utf8'));
+    return j.env || {};
+  } catch {
+    return {};
+  }
+}
+
+function readMemorySyncConfig() {
+  const paths = [
+    path.join(PROJECT_ROOT, 'loadbalancer.yaml'),
+    path.join(PROJECT_ROOT, '_byan', 'config.yaml'),
+  ];
+  for (const p of paths) {
+    if (!fs.existsSync(p)) continue;
+    try {
+      const yaml = require('js-yaml');
+      const doc = yaml.load(fs.readFileSync(p, 'utf8'));
+      if (doc && doc.memory_sync) return doc.memory_sync;
+    } catch {
+      // fall through
+    }
+  }
+  return null;
+}
+
+function buildConfig() {
+  const envFile = readSettingsEnv();
+  return {
+    byan_api_url: envFile.BYAN_API_URL || process.env.BYAN_API_URL || null,
+    byan_api_token: envFile.BYAN_API_TOKEN || process.env.BYAN_API_TOKEN || null,
+    memory_sync: readMemorySyncConfig() || {},
+  };
+}
+
+// Per-turn buffer of recent messages/tool calls keyed by sessionId.
+const turnBuffer = new Map();
+
+function bufferFor(sessionId) {
+  const key = sessionId || 'default';
+  if (!turnBuffer.has(key)) {
+    turnBuffer.set(key, { userMessages: [], assistantMessages: [], toolCalls: [] });
+  }
+  return turnBuffer.get(key);
+}
+
+function clearBuffer(sessionId) {
+  turnBuffer.delete(sessionId || 'default');
+}
+
+const session = await joinSession({
+  hooks: {
+    onSessionStart: async () => {
+      await session.log('BYAN staging extension loaded', { ephemeral: true });
+    },
+
+    onUserPromptSubmitted: async (input) => {
+      const buf = bufferFor(input.sessionId);
+      buf.userMessages.push({ role: 'user', content: input.prompt });
+    },
+
+    onPreToolUse: async (input) => {
+      const buf = bufferFor(input.sessionId);
+      buf.toolCalls.push({
+        name: input.toolName,
+        input: input.toolArgs || {},
+      });
+    },
+
+    onPostToolUse: async (input) => {
+      const buf = bufferFor(input.sessionId);
+      // If the last tool call has a text result, treat it as assistant output
+      if (input.toolResult && typeof input.toolResult.content === 'string') {
+        buf.assistantMessages.push({
+          role: 'assistant',
+          content: input.toolResult.content,
+        });
+      }
+    },
+
+    onSessionEnd: async (input) => {
+      const staging = loadStaging();
+      if (!staging) {
+        clearBuffer(input?.sessionId);
+        return;
+      }
+
+      const buf = bufferFor(input?.sessionId);
+      const turn = {
+        sessionId: input?.sessionId || null,
+        messages: [...buf.userMessages, ...buf.assistantMessages],
+        toolCalls: buf.toolCalls,
+      };
+
+      try {
+        await staging.processTurn({
+          turn,
+          cliSource: 'copilot-cli',
+          config: buildConfig(),
+          projectRoot: PROJECT_ROOT,
+          flushNow: true,
+        });
+      } catch {
+        // never block session end
+      }
+
+      clearBuffer(input?.sessionId);
+    },
+  },
+
+  tools: [],
+});

package/install/templates/.github/extensions/byan-staging/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@byan/copilot-staging-extension",
+  "version": "0.1.0",
+  "description": "Copilot CLI extension that stages conversation knowledge to byan_web /api/memory via the shared BYAN staging core.",
+  "type": "module",
+  "main": "extension.mjs",
+  "private": true
+}

package/install/templates/_byan/mcp/byan-mcp-server/lib/copilot.js

@@ -0,0 +1,148 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const COPILOT_ROOT = process.env.BYAN_COPILOT_ROOT || path.join(os.homedir(), '.copilot', 'session-state');
+
+function readJsonl(filePath, limit) {
+  if (!fs.existsSync(filePath)) return [];
+  const lines = fs.readFileSync(filePath, 'utf8').split('\n').filter(Boolean);
+  const out = [];
+  for (const line of lines) {
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+      // skip malformed
+    }
+    if (typeof limit === 'number' && out.length >= limit) break;
+  }
+  return out;
+}
+
+function summarizeSession(sessionId) {
+  const eventsPath = path.join(COPILOT_ROOT, sessionId, 'events.jsonl');
+  if (!fs.existsSync(eventsPath)) return null;
+
+  const events = readJsonl(eventsPath);
+  if (events.length === 0) return null;
+
+  const start = events.find((e) => e.type === 'session.start');
+  const shutdown = events.find((e) => e.type === 'session.shutdown');
+  const agent = events.find((e) => e.type === 'subagent.selected');
+
+  const counts = {};
+  for (const e of events) {
+    counts[e.type] = (counts[e.type] || 0) + 1;
+  }
+
+  const userMessages = events.filter((e) => e.type === 'user.message');
+  const assistantMessages = events.filter((e) => e.type === 'assistant.message');
+
+  return {
+    sessionId,
+    startTime: start?.data?.startTime || null,
+    endTime: shutdown?.timestamp || null,
+    cwd: start?.data?.context?.cwd || null,
+    branch: start?.data?.context?.branch || null,
+    agent: agent?.data?.agentName || null,
+    event_count: events.length,
+    user_messages: userMessages.length,
+    assistant_messages: assistantMessages.length,
+    tool_calls: counts['tool.execution_start'] || 0,
+    event_type_counts: counts,
+  };
+}
+
+export function listSessions({ limit = 20, sinceIso = null, cwdFilter = null } = {}) {
+  if (!fs.existsSync(COPILOT_ROOT)) return { root: COPILOT_ROOT, sessions: [], total: 0, exists: false };
+
+  const dirs = fs
+    .readdirSync(COPILOT_ROOT, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name);
+
+  const summaries = [];
+  for (const id of dirs) {
+    const s = summarizeSession(id);
+    if (!s) continue;
+    if (sinceIso && s.startTime && Date.parse(s.startTime) < Date.parse(sinceIso)) continue;
+    if (cwdFilter && s.cwd && !s.cwd.includes(cwdFilter)) continue;
+    summaries.push(s);
+  }
+
+  summaries.sort((a, b) => {
+    const at = Date.parse(a.startTime || 0);
+    const bt = Date.parse(b.startTime || 0);
+    return bt - at;
+  });
+
+  return {
+    root: COPILOT_ROOT,
+    total: summaries.length,
+    exists: true,
+    sessions: summaries.slice(0, limit),
+  };
+}
+
+export function readSessionEvents({ sessionId, types = null, limit = 200 } = {}) {
+  if (!sessionId || typeof sessionId !== 'string') {
+    throw new Error('sessionId is required');
+  }
+  const eventsPath = path.join(COPILOT_ROOT, sessionId, 'events.jsonl');
+  if (!fs.existsSync(eventsPath)) {
+    throw new Error(`events.jsonl not found for session ${sessionId}`);
+  }
+
+  const allEvents = readJsonl(eventsPath);
+  const filtered = Array.isArray(types) && types.length > 0
+    ? allEvents.filter((e) => types.includes(e.type))
+    : allEvents;
+
+  return {
+    sessionId,
+    total: allEvents.length,
+    returned: Math.min(filtered.length, limit),
+    filtered_by_type: Array.isArray(types) ? types : null,
+    events: filtered.slice(0, limit),
+  };
+}
+
+export function searchSessions({ query, types = ['user.message', 'assistant.message'], limit = 50 } = {}) {
+  if (!query || typeof query !== 'string') {
+    throw new Error('query is required');
+  }
+  if (!fs.existsSync(COPILOT_ROOT)) return { matches: [], total: 0 };
+
+  const q = query.toLowerCase();
+  const dirs = fs
+    .readdirSync(COPILOT_ROOT, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name);
+
+  const matches = [];
+  for (const sessionId of dirs) {
+    const eventsPath = path.join(COPILOT_ROOT, sessionId, 'events.jsonl');
+    if (!fs.existsSync(eventsPath)) continue;
+    const events = readJsonl(eventsPath);
+    for (const e of events) {
+      if (!types.includes(e.type)) continue;
+      const text = typeof e.data?.content === 'string'
+        ? e.data.content
+        : typeof e.data?.text === 'string'
+          ? e.data.text
+          : JSON.stringify(e.data || {});
+      if (text.toLowerCase().includes(q)) {
+        matches.push({
+          sessionId,
+          timestamp: e.timestamp,
+          type: e.type,
+          excerpt: text.slice(0, 300),
+        });
+        if (matches.length >= limit) break;
+      }
+    }
+    if (matches.length >= limit) break;
+  }
+
+  return { query, total: matches.length, matches };
+}

package/install/templates/_byan/mcp/byan-mcp-server/lib/fd-state.js

@@ -0,0 +1,163 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const PHASES = ['BRAINSTORM', 'PRUNE', 'DISPATCH', 'BUILD', 'VALIDATE', 'COMPLETED', 'ABORTED'];
+
+function resolveRoot(projectRoot) {
+  return projectRoot || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+}
+
+function statePath(projectRoot) {
+  return path.join(resolveRoot(projectRoot), '_byan-output', 'fd-state.json');
+}
+
+function ensureDir(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function readState(projectRoot) {
+  const p = statePath(projectRoot);
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeState(state, projectRoot) {
+  const p = statePath(projectRoot);
+  ensureDir(p);
+  fs.writeFileSync(p, JSON.stringify(state, null, 2));
+  return p;
+}
+
+function slugify(s) {
+  return String(s || 'feature')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/(^-|-$)/g, '')
+    .slice(0, 40);
+}
+
+function stampId(now = new Date(), slug) {
+  const pad = (n) => String(n).padStart(2, '0');
+  const s =
+    now.getFullYear().toString() +
+    pad(now.getMonth() + 1) +
+    pad(now.getDate()) +
+    '-' +
+    pad(now.getHours()) +
+    pad(now.getMinutes()) +
+    pad(now.getSeconds());
+  return `${s}-${slugify(slug)}`;
+}
+
+export function start({ featureName, projectRoot, now = new Date(), force = false } = {}) {
+  const existing = readState(projectRoot);
+  if (existing && !['COMPLETED', 'ABORTED'].includes(existing.phase) && !force) {
+    throw new Error(
+      `FD already in progress (phase ${existing.phase}, fd_id ${existing.fd_id}). Abort or complete it first, or pass force=true.`
+    );
+  }
+
+  const state = {
+    fd_id: stampId(now, featureName),
+    feature_name: featureName || 'unnamed',
+    phase: 'BRAINSTORM',
+    started_at: now.toISOString(),
+    updated_at: now.toISOString(),
+    phase_history: [{ phase: 'BRAINSTORM', entered_at: now.toISOString() }],
+    raw_ideas: [],
+    backlog: [],
+    dispatch_table: [],
+    commits: [],
+    notes: [],
+  };
+  writeState(state, projectRoot);
+  return state;
+}
+
+export function status({ projectRoot } = {}) {
+  const state = readState(projectRoot);
+  if (!state) {
+    return { active: false, phase: null, fd_id: null };
+  }
+  return {
+    active: !['COMPLETED', 'ABORTED'].includes(state.phase),
+    ...state,
+  };
+}
+
+const BRAINSTORM_MIN_IDEAS = 10;
+
+export function advance({ to, note, projectRoot, now = new Date(), force = false } = {}) {
+  if (!PHASES.includes(to)) {
+    throw new Error(`Invalid target phase ${to}. Must be one of ${PHASES.join(', ')}`);
+  }
+  const state = readState(projectRoot);
+  if (!state) throw new Error('No active FD session. Call start() first.');
+  if (['COMPLETED', 'ABORTED'].includes(state.phase)) {
+    throw new Error(`Current FD session is ${state.phase} and cannot advance.`);
+  }
+
+  const order = PHASES.indexOf(state.phase);
+  const target = PHASES.indexOf(to);
+  if (target < order && !['ABORTED', 'COMPLETED'].includes(to)) {
+    throw new Error(
+      `Cannot move backwards from ${state.phase} to ${to}. Use abort() or fix the workflow.`
+    );
+  }
+
+  // BRAINSTORM exit gate : need >= BRAINSTORM_MIN_IDEAS raw ideas
+  if (
+    state.phase === 'BRAINSTORM' &&
+    to !== 'BRAINSTORM' &&
+    !['ABORTED'].includes(to) &&
+    !force
+  ) {
+    const n = Array.isArray(state.raw_ideas) ? state.raw_ideas.length : 0;
+    if (n < BRAINSTORM_MIN_IDEAS) {
+      throw new Error(
+        `BRAINSTORM requires at least ${BRAINSTORM_MIN_IDEAS} raw ideas before advancing (currently ${n}). Add more via update({ patch: { raw_ideas: [...] } }), or pass force=true to skip.`
+      );
+    }
+  }
+
+  state.phase = to;
+  state.updated_at = now.toISOString();
+  state.phase_history.push({ phase: to, entered_at: now.toISOString(), note: note || null });
+
+  writeState(state, projectRoot);
+  return state;
+}
+
+export function update({ patch = {}, projectRoot, now = new Date() } = {}) {
+  const state = readState(projectRoot);
+  if (!state) throw new Error('No active FD session.');
+
+  const allowed = ['raw_ideas', 'backlog', 'dispatch_table', 'commits', 'notes', 'feature_name'];
+  for (const key of Object.keys(patch)) {
+    if (!allowed.includes(key)) {
+      throw new Error(`Field "${key}" is not patchable. Allowed: ${allowed.join(', ')}`);
+    }
+    state[key] = patch[key];
+  }
+  state.updated_at = now.toISOString();
+
+  writeState(state, projectRoot);
+  return state;
+}
+
+export function abort({ reason, projectRoot, now = new Date() } = {}) {
+  const state = readState(projectRoot);
+  if (!state) throw new Error('No FD session to abort.');
+  state.phase = 'ABORTED';
+  state.updated_at = now.toISOString();
+  state.phase_history.push({ phase: 'ABORTED', entered_at: now.toISOString(), note: reason || null });
+  writeState(state, projectRoot);
+  return state;
+}
+
+export const ALL_PHASES = PHASES;
+export const BRAINSTORM_MIN = BRAINSTORM_MIN_IDEAS;