@balpal4495/quorum 0.3.0 → 0.4.0

package/bin/shared/chronicle.js

@@ -0,0 +1,129 @@
+import { promises as fs } from "fs"
+import path from "path"
+
+/**
+ * Walk up from startDir looking for a .chronicle/ directory.
+ * Returns the .chronicle path if found, null otherwise.
+ */
+export async function findChronicleDir(startDir = process.cwd()) {
+  let dir = startDir
+  while (true) {
+    const candidate = path.join(dir, ".chronicle")
+    try {
+      const stat = await fs.stat(candidate)
+      if (stat.isDirectory()) return candidate
+    } catch { /* keep walking */ }
+    const parent = path.dirname(dir)
+    if (parent === dir) return null
+    dir = parent
+  }
+}
+
+/**
+ * Read all proposal JSON files from .chronicle/proposals/.
+ * Returns array of { proposalId, ...entry } objects.
+ */
+export async function readProposals(chronicleDir) {
+  const dir = path.join(chronicleDir, "proposals")
+  let files
+  try { files = await fs.readdir(dir) } catch { return [] }
+  const results = []
+  for (const file of files) {
+    if (!file.endsWith(".json")) continue
+    try {
+      const raw = await fs.readFile(path.join(dir, file), "utf8")
+      results.push({ proposalId: file.replace(".json", ""), ...JSON.parse(raw) })
+    } catch { /* skip malformed */ }
+  }
+  return results
+}
+
+/**
+ * Read all committed Chronicle entries from .chronicle/committed/.
+ * Returns ChronicleEntry array sorted newest-first.
+ */
+export async function readCommitted(chronicleDir) {
+  const dir = path.join(chronicleDir, "committed")
+  let files
+  try { files = await fs.readdir(dir) } catch { return [] }
+  const results = []
+  for (const file of files) {
+    if (!file.endsWith(".json")) continue
+    try {
+      const raw = await fs.readFile(path.join(dir, file), "utf8")
+      results.push(JSON.parse(raw))
+    } catch { /* skip malformed */ }
+  }
+  return results.sort((a, b) => b.timestamp?.localeCompare(a.timestamp ?? "") ?? 0)
+}
+
+/** entryText mirrors the shared/types.ts entryText helper. */
+export function entryText(entry) {
+  return `${entry.key_insight}. ${entry.decision ?? ""}`.trim().replace(/\.\.$/, ".")
+}
+
+/** Rebuild .chronicle/SUMMARY.md from all committed entries. */
+export async function updateSummary(chronicleDir) {
+  const SUMMARY_WEEKS = 12
+  const DIRECTIVE =
+    "<!-- Chronicle Summary v1 — temporal orientation for agents. " +
+    "Use for sequence context; query Oracle by entry ID for full reasoning. -->"
+
+  function isoWeekKey(date) {
+    const d = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()))
+    const day = d.getUTCDay() || 7
+    d.setUTCDate(d.getUTCDate() + 4 - day)
+    const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1))
+    const week = Math.ceil(((d.getTime() - yearStart.getTime()) / 86_400_000 + 1) / 7)
+    return `${d.getUTCFullYear()}-W${String(week).padStart(2, "0")}`
+  }
+
+  function workRefLabel(entry) {
+    if (!entry.work_ref) return "__none__"
+    const { type, ref } = entry.work_ref
+    return ref ? `[${type} ${ref}]` : `[${type}]`
+  }
+
+  function renderEntry(entry) {
+    const areas = entry.affected_areas.join(", ")
+    const id = entry.id.slice(0, 8)
+    return `- **[${id}]** ${areas} — \`${entry.status}\` (${entry.confidence.toFixed(2)}) — ${entryText(entry)}`
+  }
+
+  const entries = await readCommitted(chronicleDir)
+  if (entries.length === 0) return
+
+  const byWeek = new Map()
+  for (const entry of entries) {
+    const week = isoWeekKey(new Date(entry.timestamp))
+    const bucket = byWeek.get(week) ?? []
+    bucket.push(entry)
+    byWeek.set(week, bucket)
+  }
+
+  const weeks = [...byWeek.keys()].sort().reverse().slice(0, SUMMARY_WEEKS)
+  const lines = [DIRECTIVE, ""]
+
+  for (const week of weeks) {
+    lines.push(`## Week ${week}`, "")
+    const weekEntries = byWeek.get(week)
+    const byWork = new Map()
+    for (const entry of weekEntries) {
+      const key = workRefLabel(entry)
+      const bucket = byWork.get(key) ?? []
+      bucket.push(entry)
+      byWork.set(key, bucket)
+    }
+    const workKeys = [...byWork.keys()].sort((a, b) =>
+      a === "__none__" ? 1 : b === "__none__" ? -1 : a.localeCompare(b))
+    for (const key of workKeys) {
+      lines.push(key === "__none__"
+        ? `### (no work context — query Oracle by entry ID for details)`
+        : `### ${key}`)
+      for (const entry of byWork.get(key)) lines.push(renderEntry(entry))
+      lines.push("")
+    }
+  }
+
+  await fs.writeFile(path.join(chronicleDir, "SUMMARY.md"), lines.join("\n"), "utf8")
+}

package/bin/shared/colors.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+export const c = {
+  bold:   (s) => `\x1b[1m${s}\x1b[0m`,
+  green:  (s) => `\x1b[32m${s}\x1b[0m`,
+  blue:   (s) => `\x1b[34m${s}\x1b[0m`,
+  dim:    (s) => `\x1b[90m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  red:    (s) => `\x1b[31m${s}\x1b[0m`,
+  cyan:   (s) => `\x1b[36m${s}\x1b[0m`,
+  magenta:(s) => `\x1b[35m${s}\x1b[0m`,
+}
+
+export const log = {
+  section: (title) => console.log(`\n${c.bold(title)}`),
+  created: (file)  => console.log(`  ${c.green("+ created ")} ${file}`),
+  appended:(file)  => console.log(`  ${c.blue("~ appended")} ${file}`),
+  skipped: (file)  => console.log(`  ${c.dim("· skipped ")} ${file}`),
+  warn:    (msg)   => console.log(`  ${c.yellow("⚠ " + msg)}`),
+  ok:      (msg)   => console.log(`  ${c.green("✓")} ${msg}`),
+  fail:    (msg)   => console.log(`  ${c.red("✗")} ${msg}`),
+  info:    (msg)   => console.log(`  ${c.dim(msg)}`),
+}

package/bin/shared/patterns.js

@@ -0,0 +1,83 @@
+/**
+ * Mirrors modules/jury/preflight.ts (SENSITIVE_PATTERNS, ROLLBACK_PATTERN, TEST_PATTERN)
+ * and modules/council/risk.ts (RISK_RULES).
+ * Keep these in sync when modifying those files.
+ */
+
+export const SENSITIVE_PATTERNS = {
+  auth:          /\b(auth(?:entication|orization)?|jwt|token|session|password|oauth|login|logout|credential|bearer)\b/i,
+  database:      /\b(migrat(?:ion|e)|alter\s+table|schema\s+change|postgres|mysql|sqlite|prisma|drizzle|knex|sequelize)\b/i,
+  crypto:        /\b(encrypt|decrypt|cipher|hash(?:ing)?|hmac|sign(?:ing)?|verify|private\s+key|certificate|tls|ssl)\b/i,
+  payments:      /\b(payment|stripe|charge|billing|invoice|subscription|price|checkout|refund)\b/i,
+  permissions:   /\b(permission|role(?:s)?|acl|access\s+control|rbac|authorization|entitlement)\b/i,
+  pii:           /\b(pii|personal\s+data|gdpr|ccpa|email(?:\s+address)?|phone(?:\s+number)?|postal\s+address|ssn|passport)\b/i,
+  data_deletion: /\b(delete(?:\s+all)?|drop\s+table|truncate|purge|wipe|destroy.*data|hard\s+delete)\b/i,
+  secrets:       /\b(api\s+key|secret(?:s)?|env(?:ironment)?\s+var(?:iable)?|\.env|private\s+key|credentials?)\b/i,
+}
+
+export const ROLLBACK_PATTERN = /\b(rollback|roll\s+back|revert|undo|restore|recovery|fallback|backward[- ]compat)\b/i
+export const TEST_PATTERN     = /\b(test(?:ing|s)?|spec(?:ification)?|unit\s+test|integration\s+test|coverage|vitest|jest|mocha)\b/i
+
+const RISK_RULES = [
+  // Critical
+  { pattern: /\b(auth(?:entication|orization)?|jwt|token|session|password|oauth|credential|bearer)\b/i, level: "critical", reason: "authentication or authorisation logic" },
+  { pattern: /\b(payment|stripe|charge|billing|checkout|refund|subscription)\b/i,                       level: "critical", reason: "payment or billing logic" },
+  { pattern: /\b(encrypt|decrypt|private\s+key|certificate|tls|ssl|hmac|cipher)\b/i,                   level: "critical", reason: "cryptography or key management" },
+  { pattern: /\b(delete\s+all|drop\s+table|truncate|wipe|destroy.*data|hard\s+delete)\b/i,             level: "critical", reason: "irreversible data deletion" },
+  // High
+  { pattern: /\b(migrat(?:ion|e)|alter\s+table|schema\s+change|not\s+null|backfill|pg_repack|shadow\s+column)\b/i, level: "high", reason: "database schema migration" },
+  { pattern: /\b(permission|role(?:s)?|acl|rbac|access\s+control|entitlement)\b/i,                     level: "high", reason: "permissions or access control" },
+  { pattern: /\b(pii|personal\s+data|gdpr|ccpa|email(?:\s+address)?|phone(?:\s+number)?|ssn|passport)\b/i, level: "high", reason: "PII or compliance-regulated data" },
+  { pattern: /\b(api\s+key|secret(?:s)?|private\s+key|credentials?)\b/i,                               level: "high", reason: "secrets or credentials handling" },
+  // Medium
+  { pattern: /\b(cache|redis|memcached|invalidat(?:e|ion))\b/i,                                         level: "medium", reason: "cache strategy" },
+  { pattern: /\b(rate\s*limit|throttl(?:e|ing)|quota)\b/i,                                             level: "medium", reason: "rate limiting or throttling" },
+  { pattern: /\b(webhook|event|queue|pubsub|kafka|rabbitmq|sns|sqs)\b/i,                               level: "medium", reason: "async event or messaging" },
+  { pattern: /\b(deploy(?:ment)?|ci(?:\/cd)?|docker|kubernetes|infra(?:structure)?)\b/i,               level: "medium", reason: "deployment or infrastructure" },
+]
+
+const RISK_ORDER = ["low", "medium", "high", "critical"]
+
+function maxLevel(a, b) {
+  return RISK_ORDER.indexOf(a) >= RISK_ORDER.indexOf(b) ? a : b
+}
+
+export function runPreflight(outcome, design) {
+  const text = `${outcome} ${design}`
+  const sensitive_areas = Object.entries(SENSITIVE_PATTERNS)
+    .filter(([, pattern]) => pattern.test(text))
+    .map(([area]) => area)
+  return {
+    touches_sensitive_area: sensitive_areas.length > 0,
+    sensitive_areas,
+    rollback_mentioned:      ROLLBACK_PATTERN.test(text),
+    test_strategy_mentioned: TEST_PATTERN.test(text),
+  }
+}
+
+export function classifyRisk(outcome, design, refutedCount = 0) {
+  const text = `${outcome} ${design}`
+  let level = "low"
+  const reasons = []
+
+  for (const rule of RISK_RULES) {
+    if (rule.pattern.test(text)) {
+      const prev = level
+      level = maxLevel(level, rule.level)
+      if (!reasons.includes(rule.reason)) reasons.push(rule.reason)
+      void prev
+    }
+  }
+
+  if (refutedCount > 0) {
+    const refutedRisk = refutedCount >= 2 ? "high" : "medium"
+    level = maxLevel(level, refutedRisk)
+    reasons.push(`${refutedCount} refuted Chronicle ${refutedCount === 1 ? "entry" : "entries"} in evidence pack`)
+  }
+
+  return {
+    level,
+    reasons: reasons.length > 0 ? reasons : ["no sensitive patterns detected"],
+    council_mode: level === "low" ? "jury-only" : level === "medium" ? "lite" : "full",
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@balpal4495/quorum",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Portable reasoning layer for agentic codebases — Oracle, Jury, Council, Sentinel",
   "type": "module",
   "license": "MIT",
@@ -20,7 +20,7 @@
     "llm"
   ],
   "bin": {
-    "quorum": "bin/init.js"
+    "quorum": "bin/quorum.js"
   },
   "scripts": {
     "init": "node bin/init.js",