burhan-mop 0.1.0

package/.memoryofplanet/scripts/mop-workflow.mjs

@@ -0,0 +1,348 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const coreDir = resolve(here, '..');
+const rootDir = resolve(coreDir, '..');
+const statePath = join(coreDir, 'STATE.json');
+
+function now() {
+  return new Date().toISOString();
+}
+
+function readJson(path, fallback = {}) {
+  if (!existsSync(path)) return fallback;
+  return JSON.parse(readFileSync(path, 'utf8'));
+}
+
+function readState() {
+  return readJson(statePath);
+}
+
+function writeState(state) {
+  const tmp = `${statePath}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+  renameSync(tmp, statePath);
+}
+
+function parseArgs(argv) {
+  const out = { _: [] };
+  for (let i = 0; i < argv.length; i += 1) {
+    const item = argv[i];
+    if (!item.startsWith('--')) {
+      out._.push(item);
+      continue;
+    }
+    const key = item.slice(2);
+    const next = argv[i + 1];
+    if (!next || next.startsWith('--')) {
+      out[key] = true;
+    } else {
+      out[key] = next;
+      i += 1;
+    }
+  }
+  return out;
+}
+
+function requireArg(args, key) {
+  const value = args[key];
+  if (!value || value === true) throw new Error(`Missing --${key}`);
+  return String(value);
+}
+
+function slug(value) {
+  return String(value)
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+function deepMerge(base, override) {
+  if (!override || typeof override !== 'object' || Array.isArray(override)) return base;
+  const result = { ...(base || {}) };
+  for (const [key, value] of Object.entries(override)) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      result[key] = deepMerge(result[key] || {}, value);
+    } else if (value !== undefined) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+function mergedConfig(state, actor = '') {
+  const files = state.customization?.files || {};
+  const defaults = readJson(join(rootDir, files.defaults || '.memoryofplanet/config/defaults.json'));
+  const team = readJson(join(rootDir, files.team || '.memoryofplanet/config/team.json'));
+  const memberPattern = files.memberPattern || '.memoryofplanet/config/members/<codename>.json';
+  const memberPath = actor ? join(rootDir, memberPattern.replace('<codename>', slug(actor))) : '';
+  const member = memberPath ? readJson(memberPath) : {};
+  return deepMerge(deepMerge(defaults, team), member);
+}
+
+function actorAllowed(state, actor) {
+  if (!state.initialized) return true;
+  if (!actor) throw new Error('Missing --actor');
+  if (!state.members?.[actor]) throw new Error(`Unknown actor: ${actor}`);
+  return true;
+}
+
+function phaseById(state, id) {
+  return (state.workflow?.phases || []).find((phase) => phase.id === id) || null;
+}
+
+function inferPhase(state, task) {
+  const text = task.toLowerCase();
+  if (/\b(deploy|release|vercel|docker|publish)\b/.test(text)) return 'release';
+  if (/\b(review|semak|audit|bug|risk|risiko)\b/.test(text)) return 'review';
+  if (/\b(code|implement|fix|build|buat file|ubah file)\b/.test(text)) return 'readiness';
+  if (/\b(architecture|database|api|backend|security|infra)\b/.test(text)) return 'architecture';
+  if (/\b(ui|ux|design|screen|layout|animation|scroll)\b/.test(text)) return 'ux-spec';
+  if (/\b(prd|requirement|acceptance|user story)\b/.test(text)) return 'prd';
+  if (/\b(plan|idea|konsep|scope|roadmap)\b/.test(text)) return 'brief';
+  return state.workflow?.currentPhase || state.workflow?.phaseOrder?.[0] || 'idea';
+}
+
+function currentAndNext(state, task = '') {
+  const phaseId = task ? inferPhase(state, task) : (state.workflow?.currentPhase || state.workflow?.phaseOrder?.[0] || 'idea');
+  const phase = phaseById(state, phaseId) || phaseById(state, 'idea');
+  const order = state.workflow?.phaseOrder || [];
+  const index = Math.max(0, order.indexOf(phase?.id));
+  const nextPhase = phaseById(state, order[index + 1]) || null;
+  return { phase, nextPhase };
+}
+
+function status(args) {
+  const state = readState();
+  const actor = args.actor ? slug(args.actor) : '';
+  const config = mergedConfig(state, actor);
+  const { phase, nextPhase } = currentAndNext(state, String(args.task || ''));
+  console.log(JSON.stringify({
+    workflow: state.workflow?.name || 'MOP Workflow',
+    enabled: state.workflow?.enabled !== false,
+    currentPhase: state.workflow?.currentPhase,
+    suggestedPhase: phase,
+    nextPhase,
+    customization: config.workflow || {},
+    artifacts: {
+      directory: state.artifacts?.directory || '.memoryofplanet/artifacts',
+      layout: state.artifacts?.layout || 'category/artifact-slug/type.md',
+      folderByType: state.artifacts?.folderByType || {}
+    },
+    projectRootPolicy: state.projectRootPolicy || config.projectRootPolicy || {},
+    readinessGate: state.readinessGate || {},
+    adversarialReview: state.adversarialReview || {}
+  }, null, 2));
+}
+
+function help(args) {
+  const state = readState();
+  const actor = args.actor ? slug(args.actor) : '';
+  if (actor) actorAllowed(state, actor);
+  const task = String(args.task || args._?.join(' ') || '');
+  const { phase, nextPhase } = currentAndNext(state, task);
+  const readinessRequired = ['readiness', 'implementation'].includes(phase?.id) || /\b(code|implement|build|fix)\b/i.test(task);
+  const nextArtifact = phase?.artifact || 'product-brief';
+  const nextCategory = artifactCategoryFor(state, args, nextArtifact);
+  console.log(JSON.stringify({
+    question: task || 'lepas ni buat apa?',
+    answer: phase ? `Next best step: ${phase.title}.` : 'Next best step: capture the idea.',
+    phase: phase?.id || 'idea',
+    leadAgentRole: phase?.primaryRole || 'planner',
+    partyRoles: phase?.partyRoles || [],
+    nextArtifact,
+    nextArtifactCategory: nextCategory,
+    nextArtifactPathPattern: `${state.artifacts?.directory || '.memoryofplanet/artifacts'}/${nextCategory}/<artifact-slug>/${nextArtifact}.md`,
+    nextCommand: `node .memoryofplanet/scripts/mop-workflow.mjs artifact create --actor ${actor || '<codename>'} --type ${nextArtifact} --title "<title>"`,
+    readinessRequired,
+    readinessCommand: `node .memoryofplanet/scripts/mop-workflow.mjs gate readiness --actor ${actor || '<codename>'} --task "<task>"`,
+    nextPhase: nextPhase?.id || null
+  }, null, 2));
+}
+
+function setPhase(args) {
+  const state = readState();
+  const actor = slug(requireArg(args, 'actor'));
+  actorAllowed(state, actor);
+  const phase = requireArg(args, 'phase');
+  if (!phaseById(state, phase)) throw new Error(`Unknown phase: ${phase}`);
+  state.workflow.currentPhase = phase;
+  state.ledger ||= [];
+  state.ledger.push({ at: now(), actor, kind: 'workflow-phase', summary: `Set MOP workflow phase to ${phase}.` });
+  writeState(state);
+  console.log(`Workflow phase set: ${phase}`);
+}
+
+function renderTemplate(template, values) {
+  return template.replace(/\{\{([a-zA-Z0-9_-]+)\}\}/g, (_, key) => values[key] || '');
+}
+
+function artifactCategoryFor(state, args, type) {
+  const folderByType = state.artifacts?.folderByType || {};
+  const selected = args.category || args.folder || folderByType[type] || state.artifacts?.defaultCategory || 'general';
+  return slug(selected) || 'general';
+}
+
+function artifactCreate(args) {
+  const state = readState();
+  const actor = slug(requireArg(args, 'actor'));
+  actorAllowed(state, actor);
+  const type = slug(requireArg(args, 'type'));
+  if (!(state.artifacts?.types || []).includes(type)) throw new Error(`Unknown artifact type: ${type}`);
+  const title = String(args.title || type);
+  const artifactSlug = slug(args.slug || title || type);
+  const category = artifactCategoryFor(state, args, type);
+  const artifactRoot = join(rootDir, state.artifacts?.directory || '.memoryofplanet/artifacts', category, artifactSlug);
+  const templatePath = join(rootDir, state.artifacts?.templateDirectory || '.memoryofplanet/templates/artifacts', `${type}.md`);
+  const template = existsSync(templatePath)
+    ? readFileSync(templatePath, 'utf8')
+    : `# {{title}}\n\n## Notes\n\n`;
+  const outputPath = join(artifactRoot, `${type}.md`);
+  const relativePath = outputPath.replace(rootDir, '').replace(/^[\\/]/, '');
+  if (args['dry-run'] === true) {
+    console.log(JSON.stringify({
+      ok: true,
+      dryRun: true,
+      actor,
+      type,
+      category,
+      layout: state.artifacts?.layout || 'category/artifact-slug/type.md',
+      path: relativePath
+    }, null, 2));
+    return;
+  }
+  mkdirSync(artifactRoot, { recursive: true });
+  if (existsSync(outputPath) && args.force !== true) {
+    throw new Error(`Artifact already exists: ${outputPath}. Re-run with --force to overwrite.`);
+  }
+  const content = renderTemplate(template, {
+    title,
+    intent: String(args.intent || ''),
+    user: String(args.user || ''),
+    problem: String(args.problem || ''),
+    outcome: String(args.outcome || ''),
+    goal: String(args.goal || ''),
+    context: String(args.context || ''),
+    summary: String(args.summary || ''),
+    state: String(args.state || ''),
+    decision: String(args.decision || ''),
+    date: now()
+  });
+  writeFileSync(outputPath, content, 'utf8');
+  console.log(JSON.stringify({
+    ok: true,
+    actor,
+    type,
+    category,
+    layout: state.artifacts?.layout || 'category/artifact-slug/type.md',
+    path: relativePath
+  }, null, 2));
+}
+
+function readiness(args) {
+  const state = readState();
+  const actor = slug(requireArg(args, 'actor'));
+  actorAllowed(state, actor);
+  const task = String(args.task || args._?.join(' ') || '');
+  const artifact = String(args.artifact || '');
+  const text = `${task}\n${artifact && existsSync(join(rootDir, artifact)) ? readFileSync(join(rootDir, artifact), 'utf8') : ''}`.toLowerCase();
+  const checks = state.readinessGate?.checks || [];
+  const missing = [];
+  const passed = [];
+  for (const check of checks) {
+    let ok = false;
+    if (check === 'intent-clear') ok = task.length > 20;
+    else if (check === 'user-and-success-defined') ok = /\b(user|pengguna|owner|customer|success|berjaya|goal|outcome)\b/.test(text);
+    else if (check === 'scope-bounded') ok = /\b(scope|in:|out:|mvp|phase|limit|batas)\b/.test(text);
+    else if (check === 'artifacts-current') ok = Boolean(artifact) || /\b(prd|brief|architecture|story|spec)\b/.test(text);
+    else if (check === 'data-contract-clear') ok = /\b(api|data|schema|contract|interface|field|endpoint|storage)\b/.test(text);
+    else if (check === 'acceptance-criteria-present') ok = /\b(acceptance|criteria|done|siap|test|expected)\b/.test(text);
+    else if (check === 'risks-reviewed') ok = /\b(risk|risiko|tradeoff|edge|failure|fallback)\b/.test(text);
+    else if (check === 'tests-planned') ok = /\b(test|testing|qa|validate|verification|playwright|unit)\b/.test(text);
+    else if (check === 'rollback-or-undo-known') ok = /\b(rollback|undo|backup|revert|restore)\b/.test(text);
+    if (ok) passed.push(check);
+    else missing.push(check);
+  }
+  const status = missing.length === 0 ? 'ready' : missing.length <= 3 ? 'needs-clarity' : 'blocked';
+  console.log(JSON.stringify({
+    status,
+    canCode: status === 'ready',
+    passed,
+    missing,
+    questions: missing.map((check) => `Clarify ${check.replaceAll('-', ' ')}.`),
+    next: status === 'ready'
+      ? 'Proceed to implementation with autosycn.'
+      : 'Ask clarification or create/update the required artifact before coding.'
+  }, null, 2));
+}
+
+function adversarialReview(args) {
+  const state = readState();
+  const actor = slug(requireArg(args, 'actor'));
+  actorAllowed(state, actor);
+  const target = String(args.target || args.task || args._?.join(' ') || '');
+  const mode = String(args.mode || state.adversarialReview?.defaultMode || 'constructive-red-team');
+  const result = {
+    mode,
+    target,
+    reviewRoles: state.adversarialReview?.reviewRoles || [],
+    prompts: [
+      'What assumption could be false?',
+      'Where could user intent be misunderstood?',
+      'What breaks on mobile, slow devices, or bad network?',
+      'What security/privacy issue could appear?',
+      'What test would catch the most expensive failure?',
+      'What is the smallest safer version?'
+    ],
+    verdictOptions: ['proceed', 'proceed-with-changes', 'block']
+  };
+  if (args.write === true) {
+    artifactCreate({
+      actor,
+      type: 'adversarial-review',
+      title: String(args.title || 'Adversarial Review'),
+      context: target,
+      force: args.force
+    });
+  }
+  console.log(JSON.stringify(result, null, 2));
+}
+
+function configShow(args) {
+  const state = readState();
+  const actor = args.actor ? slug(args.actor) : '';
+  console.log(JSON.stringify(mergedConfig(state, actor), null, 2));
+}
+
+function main() {
+  const [command, subcommand, ...rest] = process.argv.slice(2);
+  const args = parseArgs(rest);
+  if (command === 'status') return status(args);
+  if (command === 'help' || command === 'next') return help(parseArgs([subcommand, ...rest].filter(Boolean)));
+  if (command === 'phase' && subcommand === 'set') return setPhase(args);
+  if (command === 'artifact' && subcommand === 'create') return artifactCreate(args);
+  if (command === 'gate' && subcommand === 'readiness') return readiness(args);
+  if (command === 'review' && subcommand === 'adversarial') return adversarialReview(args);
+  if (command === 'config' && subcommand === 'show') return configShow(args);
+
+  console.log(`Usage:
+  node .memoryofplanet/scripts/mop-workflow.mjs status [--actor CODE] [--task TEXT]
+  node .memoryofplanet/scripts/mop-workflow.mjs help --actor CODE --task "what user asked"
+  node .memoryofplanet/scripts/mop-workflow.mjs next --actor CODE --task "what user asked"
+  node .memoryofplanet/scripts/mop-workflow.mjs phase set --actor CODE --phase prd
+  node .memoryofplanet/scripts/mop-workflow.mjs artifact create --actor CODE --type prd --title "Title" [--category plan] [--dry-run]
+  node .memoryofplanet/scripts/mop-workflow.mjs gate readiness --actor CODE --task "task" [--artifact path]
+  node .memoryofplanet/scripts/mop-workflow.mjs review adversarial --actor CODE --target "plan or file" [--write]
+  node .memoryofplanet/scripts/mop-workflow.mjs config show [--actor CODE]`);
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error.message);
+  process.exitCode = 1;
+}

package/.memoryofplanet/templates/artifacts/adversarial-review.md

@@ -0,0 +1,33 @@
+# {{title}} Adversarial Review
+
+## Challenge
+
+What could be wrong with the current plan?
+
+## Assumption Attacks
+
+- 
+
+## Failure Modes
+
+- 
+
+## Security / Privacy Risks
+
+- 
+
+## UX / Product Risks
+
+- 
+
+## Performance / Operational Risks
+
+- 
+
+## Safer Alternatives
+
+- 
+
+## Verdict
+
+proceed | proceed-with-changes | block

package/.memoryofplanet/templates/artifacts/architecture.md

@@ -0,0 +1,28 @@
+# {{title}} Architecture
+
+## Context
+
+{{context}}
+
+## System Shape
+
+- Frontend:
+- Backend:
+- Data:
+- Integrations:
+
+## Data Contracts
+
+- 
+
+## Key Decisions
+
+- 
+
+## Risks / Tradeoffs
+
+- 
+
+## Deployment
+
+- 

package/.memoryofplanet/templates/artifacts/decision-log.md

@@ -0,0 +1,21 @@
+# {{title}} Decision Log
+
+## Decision
+
+{{decision}}
+
+## Context
+
+{{context}}
+
+## Options Considered
+
+- 
+
+## Consequences
+
+- 
+
+## Date
+
+{{date}}

package/.memoryofplanet/templates/artifacts/handoff.md

@@ -0,0 +1,21 @@
+# {{title}} Handoff
+
+## Current State
+
+{{state}}
+
+## Done
+
+- 
+
+## Next
+
+- 
+
+## Blockers
+
+- 
+
+## Important Context
+
+- 

package/.memoryofplanet/templates/artifacts/implementation-notes.md

@@ -0,0 +1,21 @@
+# {{title}} Implementation Notes
+
+## Summary
+
+{{summary}}
+
+## Files Changed
+
+- 
+
+## Decisions
+
+- 
+
+## Tests / Validation
+
+- 
+
+## Follow Up
+
+- 

package/.memoryofplanet/templates/artifacts/prd.md

@@ -0,0 +1,29 @@
+# {{title}} PRD
+
+## Goal
+
+{{goal}}
+
+## Users
+
+- 
+
+## Requirements
+
+- 
+
+## User Stories
+
+- As a user, I want ... so that ...
+
+## Acceptance Criteria
+
+- 
+
+## Risks
+
+- 
+
+## Open Questions
+
+- 

package/.memoryofplanet/templates/artifacts/product-brief.md

@@ -0,0 +1,30 @@
+# {{title}}
+
+## Intent
+
+{{intent}}
+
+## User
+
+{{user}}
+
+## Problem
+
+{{problem}}
+
+## Desired Outcome
+
+{{outcome}}
+
+## Scope
+
+- In:
+- Out:
+
+## Unknowns
+
+- 
+
+## Next Phase
+
+PRD

package/.memoryofplanet/templates/artifacts/readiness-report.md

@@ -0,0 +1,25 @@
+# {{title}} Readiness Report
+
+## Status
+
+blocked | needs-clarity | ready
+
+## Checks
+
+- [ ] intent-clear
+- [ ] user-and-success-defined
+- [ ] scope-bounded
+- [ ] artifacts-current
+- [ ] data-contract-clear
+- [ ] acceptance-criteria-present
+- [ ] risks-reviewed
+- [ ] tests-planned
+- [ ] rollback-or-undo-known
+
+## Missing Information
+
+- 
+
+## Decision
+
+- 

package/.memoryofplanet/templates/artifacts/release-notes.md

@@ -0,0 +1,21 @@
+# {{title}} Release Notes
+
+## Changes
+
+- 
+
+## Validation
+
+- 
+
+## Deployment
+
+- 
+
+## Rollback
+
+- 
+
+## Handoff
+
+- 

package/.memoryofplanet/templates/artifacts/review.md

@@ -0,0 +1,21 @@
+# {{title}} Review
+
+## Findings
+
+- 
+
+## Risks
+
+- 
+
+## Required Changes
+
+- 
+
+## Tests
+
+- 
+
+## Decision
+
+approved | changes-requested | blocked

package/.memoryofplanet/templates/artifacts/story.md

@@ -0,0 +1,25 @@
+# {{title}} Implementation Story
+
+## Story
+
+As a user, I want ... so that ...
+
+## Scope
+
+- 
+
+## Tasks
+
+- [ ] 
+
+## Acceptance Criteria
+
+- [ ] 
+
+## Test Plan
+
+- 
+
+## Dependencies
+
+- 

package/.memoryofplanet/templates/artifacts/ux-spec.md

@@ -0,0 +1,32 @@
+# {{title}} UX Spec
+
+## Experience Goal
+
+{{goal}}
+
+## Key Flows
+
+- 
+
+## Screens / States
+
+- Default:
+- Loading:
+- Empty:
+- Error:
+- Success:
+
+## Visual Direction
+
+- 
+
+## Interaction / Motion
+
+- 
+
+## Accessibility
+
+- Keyboard:
+- Screen reader:
+- Contrast:
+- Reduced motion: