mcp-council-server 4.0.0

package/src/analysis/parser.js

@@ -0,0 +1,92 @@
+const STOPWORDS = new Set([
+  'dan','di','ke','dari','yang','ini','itu','dengan','untuk','pada',
+  'adalah','akan','dapat','telah','sudah','bisa','juga','atau','tidak',
+  'the','and','for','with','that','this','from','are','have','has','had',
+  'but','not','you','all','can','was','were','been','being','does','done',
+  'get','got','may','say','said','make','made','like','just','more','some',
+  'there','their','they','what','when','where','which','who','whom','why',
+  'how','much','many','very','too','so','if','then','than','about','into',
+  'over','after','before','between','under','again','further','once','here',
+  'there','each','few','both','same','own','saya','kami','kita','dia',
+  'mereka','saja','pun','masih','belum','pernah','sedang','telah',
+  'bakal','hendak','mau','ingin','harus','boleh','mungkin','akan',
+  'selalu','sering','jarang','baru','lalu','kemudian','sekarang'
+]);
+
+export function parseTaskStructure(task) {
+  const lines = task.split('\n');
+  const sentences = task.split(/[.!?]+/).filter(s => s.trim().length > 0);
+
+  const structure = {
+    sentenceCount: sentences.length,
+    bulletPoints: 0,
+    numberedPoints: 0,
+    explicitQuestions: [],
+    codeBlocks: 0,
+    structuralSections: [],
+    keywords: []
+  };
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    if (trimmed.startsWith('- ') || trimmed.startsWith('* ')) {
+      structure.bulletPoints++;
+    }
+
+    if (/^\d+[\.\)]\s/.test(trimmed)) {
+      structure.numberedPoints++;
+    }
+
+    const headerMatch = trimmed.match(/^#{1,6}\s(.+)/);
+    if (headerMatch) {
+      structure.structuralSections.push(headerMatch[1]);
+    }
+  }
+
+  for (const sentence of sentences) {
+    if (sentence.includes('?')) {
+      structure.explicitQuestions.push(sentence.trim());
+    }
+  }
+
+  const codeMatches = task.match(/```/g);
+  structure.codeBlocks = codeMatches ? Math.floor(codeMatches.length / 2) : 0;
+
+  const words = task.toLowerCase()
+    .split(/[\s,.;:!?()\[\]{}<>"'\/\\|=+`~@#$%^&*]+/)
+    .filter(w => w.length > 3 && !STOPWORDS.has(w));
+
+  const freq = {};
+  for (const w of words) {
+    freq[w] = (freq[w] || 0) + 1;
+  }
+
+  structure.keywords = Object.entries(freq)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 15)
+    .map(([word, count]) => `${word}(${count})`);
+
+  return structure;
+}
+
+export function extractDeliverables(output) {
+  if (!output || typeof output !== 'object') return ['output kosong'];
+  const keys = Object.keys(output);
+  return keys.filter(k => {
+    const v = output[k];
+    return Array.isArray(v) ? v.length > 0 : Boolean(v);
+  }).map(k => `${k}: ${formatPreview(output[k])}`);
+}
+
+function formatPreview(value) {
+  if (Array.isArray(value)) return `${value.length} item`;
+  if (typeof value === 'string') return value.length > 60 ? value.slice(0, 60) + '...' : value;
+  if (typeof value === 'object') return JSON.stringify(value).slice(0, 60);
+  return String(value);
+}
+
+export function extractUnresolved(output) {
+  if (!output?.knowledgeBoundary?.whatIDontKnow) return [];
+  return output.knowledgeBoundary.whatIDontKnow;
+}

package/src/config.js

@@ -0,0 +1,26 @@
+import 'dotenv/config';
+import { randomUUID } from 'node:crypto';
+
+export const CONFIG = {
+  DB_PATH: process.env.COUNCIL_DB_PATH || './data/council.db',
+  SESSION_TTL_HOURS: parseInt(process.env.COUNCIL_SESSION_TTL_HOURS || '24'),
+
+  MAX_TASK_LENGTH: parseInt(process.env.COUNCIL_MAX_TASK_LENGTH || '10000'),
+  MAX_CONTEXT_LENGTH: parseInt(process.env.COUNCIL_MAX_CONTEXT_LENGTH || '5000'),
+
+  CONFIDENCE_THRESHOLD: parseFloat(process.env.COUNCIL_CONFIDENCE_THRESHOLD || '0.7'),
+  SCORE_PASS_THRESHOLD: parseInt(process.env.COUNCIL_SCORE_PASS_THRESHOLD || '70'),
+  MAX_CRITIQUE_LOOPS: parseInt(process.env.COUNCIL_MAX_CRITIQUE_LOOPS || '3'),
+
+  SCORE_WEIGHTS: {
+    completeness: 0.25,
+    consistency: 0.25,
+    decisionQuality: 0.15,
+    structure: 0.10,
+    transparency: 0.15,
+    agentic: 0.10
+  },
+
+  uuidv4: randomUUID,
+  VERSION: '4.0.0'
+};

package/src/db/database.js

@@ -0,0 +1,12 @@
+import { initStore } from './json-store.js';
+import { runMigrations } from './migrations.js';
+
+let initialized = false;
+
+export function getDb() {
+  if (initialized) return true;
+
+  runMigrations();
+  initialized = true;
+  return true;
+}

package/src/db/json-store.js

@@ -0,0 +1,122 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { CONFIG } from '../config.js';
+
+const cache = {};
+const DATA_DIR = dirname(CONFIG.DB_PATH);
+
+function ensureDir() {
+  mkdirSync(DATA_DIR, { recursive: true });
+}
+
+function filePath(collection) {
+  return join(DATA_DIR, `${collection}.json`);
+}
+
+export function initStore(collection) {
+  // Skip if already loaded and has data
+  if (cache[collection]) return;
+
+  ensureDir();
+  const path = filePath(collection);
+
+  if (existsSync(path)) {
+    try {
+      const raw = readFileSync(path, 'utf-8');
+      cache[collection] = JSON.parse(raw);
+      return;
+    } catch {
+      // Corrupted file — reset
+    }
+  }
+
+  cache[collection] = [];
+  flushStore(collection);
+}
+
+export function flushStore(collection) {
+  ensureDir();
+  const path = filePath(collection);
+  writeFileSync(path, JSON.stringify(cache[collection] || [], null, 2), 'utf-8');
+}
+
+function getCol(collection) {
+  if (!cache[collection]) initStore(collection);
+  return cache[collection];
+}
+
+export function getAll(collection) {
+  return [...getCol(collection)];
+}
+
+export function getById(collection, id) {
+  return getCol(collection).find(item => item.id === id) || null;
+}
+
+export function findMany(collection, predicate) {
+  return getCol(collection).filter(predicate);
+}
+
+export function findOne(collection, predicate) {
+  return getCol(collection).find(predicate) || null;
+}
+
+export function insert(collection, doc) {
+  const col = getCol(collection);
+  col.push({ ...doc });
+  flushStore(collection);
+  return doc;
+}
+
+export function updateWhere(collection, predicate, updates) {
+  const col = getCol(collection);
+  let count = 0;
+
+  for (let i = 0; i < col.length; i++) {
+    if (predicate(col[i])) {
+      col[i] = { ...col[i], ...updates };
+      count++;
+    }
+  }
+
+  if (count > 0) flushStore(collection);
+  return count;
+}
+
+export function upsert(collection, predicate, doc) {
+  const col = getCol(collection);
+  const idx = col.findIndex(predicate);
+
+  if (idx >= 0) {
+    col[idx] = { ...col[idx], ...doc };
+    flushStore(collection);
+    return col[idx];
+  }
+
+  col.push({ ...doc });
+  flushStore(collection);
+  return doc;
+}
+
+export function deleteWhere(collection, predicate) {
+  const col = getCol(collection);
+  const before = col.length;
+  cache[collection] = col.filter(item => !predicate(item));
+
+  if (cache[collection].length !== before) {
+    flushStore(collection);
+  }
+
+  return before - cache[collection].length;
+}
+
+export function count(collection, predicate) {
+  if (!predicate) return getCol(collection).length;
+  return getCol(collection).filter(predicate).length;
+}
+
+export function getNextOrder(collection, sessionId) {
+  const col = getCol(collection);
+  const sessionItems = col.filter(item => item.session_id === sessionId);
+  return sessionItems.length > 0 ? Math.max(...sessionItems.map(i => i.order_num || 0)) + 1 : 1;
+}

package/src/db/migrations.js

@@ -0,0 +1,16 @@
+import { initStore } from './json-store.js';
+
+const COLLECTIONS = [
+  'sessions',
+  'phases',
+  'decisions',
+  'claims',
+  'transparency_log',
+  'phase_handoffs'
+];
+
+export function runMigrations() {
+  for (const col of COLLECTIONS) {
+    initStore(col);
+  }
+}

package/src/index.js

@@ -0,0 +1,28 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { getDb } from './db/database.js';
+import { CONFIG } from './config.js';
+import { registerCouncilTools } from './tools.js';
+
+getDb();
+
+const server = new McpServer({
+  name: 'mcp-council-server',
+  version: CONFIG.VERSION,
+  description: 'Council MCP — Memory, State & Scaffolding untuk AI Utama. ' +
+    'Berbasis 3 prinsip: ADAPTIF | TRANSPARANSI | AGENTIC'
+});
+
+registerCouncilTools(server);
+
+async function main() {
+  try {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+  } catch (err) {
+    console.error('FATAL:', err);
+    process.exit(1);
+  }
+}
+
+main();

package/src/memory/decision.js

@@ -0,0 +1,37 @@
+import { CONFIG } from '../config.js';
+import { insert, findMany } from '../db/json-store.js';
+
+function parseDecision(row) {
+  return {
+    ...row,
+    alternatives: typeof row.alternatives === 'string' ? JSON.parse(row.alternatives) : (row.alternatives || []),
+    rejected_reasons: typeof row.rejected_reasons === 'string' ? JSON.parse(row.rejected_reasons) : (row.rejected_reasons || {})
+  };
+}
+
+export function saveDecision(sessionId, phaseName, description, rationale, alternatives, rejectedReasons) {
+  const id = CONFIG.uuidv4();
+  insert('decisions', {
+    id,
+    session_id: sessionId,
+    phase_name: phaseName,
+    description,
+    rationale: rationale || '',
+    alternatives: JSON.stringify(alternatives || []),
+    rejected_reasons: JSON.stringify(rejectedReasons || {}),
+    created_at: new Date().toISOString()
+  });
+  return id;
+}
+
+export function getDecisions(sessionId) {
+  return findMany('decisions', d => d.session_id === sessionId)
+    .sort((a, b) => new Date(a.created_at) - new Date(b.created_at))
+    .map(parseDecision);
+}
+
+export function getDecisionsByPhase(sessionId, phaseName) {
+  return findMany('decisions', d => d.session_id === sessionId && d.phase_name === phaseName)
+    .sort((a, b) => new Date(a.created_at) - new Date(b.created_at))
+    .map(parseDecision);
+}

package/src/memory/phase.js

@@ -0,0 +1,82 @@
+import { CONFIG } from '../config.js';
+import { findOne, findMany, updateWhere } from '../db/json-store.js';
+
+function parsePhase(row) {
+  if (!row) return null;
+  return {
+    ...row,
+    output: row.output ? (typeof row.output === 'string' ? JSON.parse(row.output) : row.output) : null,
+    knowledge_boundary: typeof row.knowledge_boundary === 'string' ? JSON.parse(row.knowledge_boundary) : (row.knowledge_boundary || {}),
+    certainty_summary: typeof row.certainty_summary === 'string' ? JSON.parse(row.certainty_summary) : (row.certainty_summary || {}),
+    authority_warnings: typeof row.authority_warnings === 'string' ? JSON.parse(row.authority_warnings) : (row.authority_warnings || [])
+  };
+}
+
+export function getActivePhase(sessionId) {
+  const row = findOne('phases', p => p.session_id === sessionId && p.status === 'active');
+  return parsePhase(row);
+}
+
+export function getPhase(sessionId, name) {
+  const row = findOne('phases', p => p.session_id === sessionId && p.name === name);
+  return parsePhase(row);
+}
+
+export function getAllPhases(sessionId) {
+  const rows = findMany('phases', p => p.session_id === sessionId)
+    .sort((a, b) => a.order_num - b.order_num);
+  return rows.map(parsePhase);
+}
+
+export function savePhaseOutput(sessionId, name, output, confidence, kb, certainty, warnings) {
+  updateWhere('phases',
+    p => p.session_id === sessionId && p.name === name,
+    {
+      status: 'done',
+      output: JSON.stringify(output),
+      confidence: confidence ?? null,
+      knowledge_boundary: JSON.stringify(kb || {}),
+      certainty_summary: JSON.stringify(certainty || {}),
+      authority_warnings: JSON.stringify(warnings || []),
+      completed_at: new Date().toISOString()
+    }
+  );
+  return getPhase(sessionId, name);
+}
+
+export function validatePhaseTransition(sessionId, currentPhaseName, targetPhaseName) {
+  if (currentPhaseName !== targetPhaseName) {
+    return { valid: false, error: `Fase '${targetPhaseName}' tidak aktif. Fase saat ini: '${currentPhaseName}'. Selesaikan fase '${currentPhaseName}' terlebih dahulu.` };
+  }
+
+  const phase = getPhase(sessionId, targetPhaseName);
+  if (!phase) {
+    return { valid: false, error: `Fase '${targetPhaseName}' tidak ditemukan.` };
+  }
+  if (phase.status === 'done') {
+    return { valid: false, error: `Fase '${targetPhaseName}' sudah selesai. Tidak bisa overwrite.` };
+  }
+  if (phase.status !== 'active') {
+    return { valid: false, error: `Fase '${targetPhaseName}' belum aktif. Selesaikan fase sebelumnya.` };
+  }
+
+  return { valid: true };
+}
+
+export function unlockNextPhase(sessionId, currentPhaseName) {
+  const current = getPhase(sessionId, currentPhaseName);
+  if (!current) return null;
+
+  const next = findOne('phases',
+    p => p.session_id === sessionId && p.order_num === (current.order_num + 1) && p.status === 'pending'
+  );
+
+  if (!next) return null;
+
+  updateWhere('phases',
+    p => p.id === next.id,
+    { status: 'active', started_at: new Date().toISOString() }
+  );
+
+  return getPhase(sessionId, next.name);
+}

package/src/memory/recall.js

@@ -0,0 +1,108 @@
+import { getSession } from './session.js';
+import { getAllPhases, getActivePhase } from './phase.js';
+import { getDecisions } from './decision.js';
+import { detectContradictions } from '../verify/contradiction.js';
+import { getPersona } from '../prinsip/agentic.js';
+import { getPhaseInstructions } from '../prinsip/adaptive.js';
+
+export function composeRecallContext(sessionId, focus, format) {
+  const session = getSession(sessionId);
+  if (!session) return null;
+
+  const allPhases = getAllPhases(sessionId);
+  const decisions = getDecisions(sessionId);
+  const completedPhases = allPhases.filter(p => p.status === 'done');
+  const activePhase = getActivePhase(sessionId);
+
+  let filteredPhases = allPhases;
+  if (focus && focus.length > 0) {
+    filteredPhases = allPhases.filter(p => focus.includes(p.name));
+  }
+
+  if (format === 'summary') {
+    return {
+      session: {
+        id: session.id,
+        task: session.task.length > 200 ? session.task.slice(0, 200) + '...' : session.task,
+        status: session.status,
+        currentPhase: session.current_phase,
+        complexity: session.complexity
+      },
+      phases: completedPhases.map(p => ({
+        name: p.name,
+        status: p.status,
+        confidence: p.confidence,
+        persona: p.persona
+      })),
+      progress: `${completedPhases.length}/${allPhases.length}`,
+      activePersona: activePhase ? getPersona(activePhase.name).name : null
+    };
+  }
+
+  if (format === 'decisions') {
+    return {
+      session: { id: session.id },
+      decisions: decisions.map(d => ({
+        phase: d.phase_name,
+        description: d.description,
+        rationale: d.rationale,
+        alternatives: d.alternatives,
+        rejectedReasons: d.rejected_reasons
+      }))
+    };
+  }
+
+  // full
+  const baseContext = {
+    session: {
+      id: session.id,
+      task: session.task,
+      context: session.context,
+      status: session.status,
+      currentPhase: session.current_phase,
+      complexity: session.complexity,
+      adaptationPlan: session.adaptation_plan,
+      createdAt: session.created_at
+    },
+    phases: filteredPhases.filter(p => p.status === 'done').map(p => ({
+      name: p.name,
+      persona: p.persona,
+      depth: p.depth,
+      status: p.status,
+      output: p.output,
+      confidence: p.confidence,
+      knowledgeBoundary: p.knowledge_boundary,
+      completedAt: p.completed_at
+    })),
+    decisions,
+    completedCount: completedPhases.length,
+    totalCount: allPhases.length
+  };
+
+  if (activePhase) {
+    const persona = getPersona(activePhase.name);
+    baseContext.currentPhase = {
+      name: activePhase.name,
+      persona: persona.name,
+      personaIdentity: persona.identity,
+      instructions: getPhaseInstructions(activePhase.name, activePhase.depth)
+    };
+  }
+
+  const warnings = [];
+  for (let i = 1; i < completedPhases.length; i++) {
+    const curr = completedPhases[i];
+    const prevs = completedPhases.slice(0, i);
+    if (curr.output) {
+      const contradictions = detectContradictions(curr.output, prevs);
+      if (contradictions.length > 0) {
+        warnings.push({ from: curr.name, issues: contradictions.slice(0, 3) });
+      }
+    }
+  }
+  if (warnings.length > 0) {
+    baseContext.warnings = warnings;
+  }
+
+  return baseContext;
+}

package/src/memory/session.js

@@ -0,0 +1,80 @@
+import { CONFIG } from '../config.js';
+import { insert, getById, updateWhere, findOne, deleteWhere } from '../db/json-store.js';
+import { insert as insertPhase } from '../db/json-store.js';
+
+export function createSession(task, context, title, complexity, adaptationPlan) {
+  const id = CONFIG.uuidv4();
+  const now = new Date().toISOString();
+
+  const session = {
+    id,
+    title: title || '',
+    task,
+    context: context || '',
+    status: 'active',
+    current_phase: adaptationPlan[0]?.name || 'decompile',
+    complexity: JSON.stringify(complexity),
+    adaptation_plan: JSON.stringify(adaptationPlan),
+    created_at: now,
+    updated_at: now
+  };
+
+  insert('sessions', session);
+
+  // Create phase records
+  adaptationPlan.forEach((p, i) => {
+    insertPhase('phases', {
+      id: CONFIG.uuidv4(),
+      session_id: id,
+      name: p.name,
+      order_num: i + 1,
+      status: i === 0 ? 'active' : 'pending',
+      persona: p.persona || '',
+      depth: p.depth || 'standard',
+      output: null,
+      confidence: null,
+      knowledge_boundary: '{}',
+      certainty_summary: '{}',
+      authority_warnings: '[]',
+      started_at: i === 0 ? now : null,
+      completed_at: null
+    });
+  });
+
+  return id;
+}
+
+export function getSession(sessionId) {
+  const row = getById('sessions', sessionId);
+  if (!row) return null;
+
+  return {
+    ...row,
+    complexity: JSON.parse(row.complexity || '{}'),
+    adaptation_plan: JSON.parse(row.adaptation_plan || '[]')
+  };
+}
+
+export function updateSessionStatus(sessionId, status) {
+  updateWhere('sessions', s => s.id === sessionId, {
+    status,
+    updated_at: new Date().toISOString()
+  });
+}
+
+export function updateSessionPhase(sessionId, phaseName) {
+  updateWhere('sessions', s => s.id === sessionId, {
+    current_phase: phaseName,
+    updated_at: new Date().toISOString()
+  });
+}
+
+export function deleteOldSessions() {
+  const cutoff = new Date();
+  cutoff.setHours(cutoff.getHours() - CONFIG.SESSION_TTL_HOURS);
+
+  const deleted = deleteWhere('sessions', s =>
+    new Date(s.created_at) < cutoff
+  );
+  return deleted;
+}