slop-ai-indo 1.0.2 → 1.2.0

package/DESIGN.md

@@ -69,6 +69,13 @@ Untuk aplikasi otomatisasi alur, diagram, atau kanvas multi-agent:
 * **Laravel / PHP:**
   * Kode PSR-12 bersih.
   * Hapus komentar redundan yang hanya mengulang nama fungsi.
+  * DILARANG membuat DocBlock/PHPDoc boilerplate (`/** ... */`) yang hanya memparafrase nama fungsi atau mengulang tipe data (seperti `/** Get all setup menus... @return Collection */`). Gunakan native type hint (PHP 8+). DocBlock HANYA diizinkan untuk tipe generic kompleks static analysis (PHPStan/Psalm) tanpa kalimat deskripsi hampa.
+  * Terapkan Skinny Controller: validasi wajib dipisah ke Form Request, logika bisnis diekstrak ke Action Class / Service Layer.
+  * Wajib bungkus response publik dengan API Resource (`JsonResource`) atau DTO; DILARANG mengembalikan Model Eloquent mentah ke JSON client.
+  * Gunakan Guard Clauses / Early Return untuk menjaga kedalaman indentasi logika maksimal 2 tingkat.
+  * Data Master & Konfigurasi: Wajib buatkan tabel database (Master / Lookup / Reference Tables) untuk data opsi, kategori, atau konfigurasi yang berpotensi dinamis agar mudah dirawat tanpa redeploy kode. Hardcode (Backed Enum / Config) HANYA untuk alur status tertutup (state machine) yang terikat langsung dengan percabangan logika kode.
+  * DILARANG menggunakan `protected $guarded = []`. Wajib deklarasikan `$fillable` secara eksplisit atau hanya passing `$request->validated()` untuk mencegah celah Mass Assignment.
+  * Migrasi Database: Foreign key wajib gunakan `$table->foreignId()->constrained()->cascadeOnDelete()` dan beri `->index()` pada kolom yang sering disaring/diurutkan (`status`, `slug`, `created_at`).
   * Blade/Inertia views menggunakan utilitas CSS dengan siku tajam (`rounded-sm` atau `rounded`, jangan `rounded-full`).
 * **Flutter:**
   * Widget menggunakan `RoundedRectangleBorder(borderRadius: BorderRadius.circular(4))`.
@@ -77,6 +84,10 @@ Untuk aplikasi otomatisasi alur, diagram, atau kanvas multi-agent:
 * **CSS / Tailwind:**
   * Gunakan `border-radius: 4px` atau `border-radius: 6px`.
   * Hindari class `rounded-2xl`, `rounded-3xl`, `rounded-full` kecuali untuk avatar pengguna berbentuk lingkaran.
+* **URL & Routing (Clean / Semantic URLs):**
+  * Wajib gunakan URL semantik RESTful dan slug (`/articles/{article:slug}`, `/users/{id}/edit`), DILARANG menggunakan query string untuk routing halaman atau identifier entitas (`?id=123`, `?page=settings`, `?action=delete`).
+  * Query string (`?`) HANYA diizinkan untuk filter opsional, pencarian, dan paginasi (`?category=tech&page=2`).
+  * Seluruh parameter URL wajib diproses via parameter binding (Prepared Statements / ORM) untuk proteksi mutlak dari SQL Injection dan IDOR.
 
 ---
 

package/bin/slop-lint.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import path from 'node:path'
+import pc from 'picocolors'
+import { lintPath } from '../lib/linter.mjs'
+
+const args = process.argv.slice(2)
+const isJson = args.includes('--json')
+const isQuiet = args.includes('--quiet')
+const tierArg = args.find((a) => a.startsWith('--tier='))
+const tier = tierArg ? tierArg.split('=')[1] : 'all'
+
+const targetArg = args.find((a) => !a.startsWith('--')) || '.'
+const targetPath = path.resolve(process.cwd(), targetArg)
+
+try {
+  const result = lintPath(targetPath, { tier })
+
+  if (isJson) {
+    console.log(JSON.stringify(result, null, 2))
+    process.exit(result.passed ? 0 : 1)
+  }
+
+  if (!isQuiet) {
+    console.log(pc.bold(pc.cyan('\n🔍 slop-lint: Mesin Linter Deterministik Slop AI Indo')))
+    console.log(pc.dim(`Memeriksa: ${targetPath}\n`))
+  }
+
+  if (result.findings.length === 0) {
+    if (!isQuiet) {
+      console.log(pc.green('✔ BERSIH:') + pc.dim(` ${result.scannedFiles} file diperiksa, nol slop terdeteksi.`))
+      console.log(pc.bold(pc.green('Status: PASSED (Lolos Delivery Gate)\n')))
+    }
+    process.exit(0)
+  }
+
+  // Group findings by file
+  const byFile = new Map()
+  for (const f of result.findings) {
+    if (!byFile.has(f.file)) byFile.set(f.file, [])
+    byFile.get(f.file).push(f)
+  }
+
+  for (const [file, items] of byFile.entries()) {
+    const relFile = path.relative(process.cwd(), file)
+    console.log(pc.bold(pc.underline(relFile)))
+    for (const item of items) {
+      const isHard = item.tier === 'Hard Gate'
+      const tierBadge = isHard ? pc.red(`[${item.tier}]`) : pc.yellow(`[${item.tier}]`)
+      const ruleCode = pc.bold(item.ruleId)
+      console.log(`  ${pc.dim(`baris ${item.line}`)} ${tierBadge} ${ruleCode} ${pc.bold(item.name)}`)
+      console.log(`    ${pc.dim('Kode:')} ${pc.italic(item.snippet)}`)
+      console.log(`    ${pc.cyan('Solusi:')} ${item.fix}\n`)
+    }
+  }
+
+  console.log(pc.dim('─'.repeat(60)))
+  console.log(
+    `Total diperiksa: ${pc.bold(result.scannedFiles)} file | Ditemukan: ${pc.bold(result.counts.total)} temuan ` +
+    `(${pc.red(`${result.counts.hardGate} Hard Gate`)}, ${pc.yellow(`${result.counts.qualityLocks} Quality Lock`)})`
+  )
+
+  if (result.passed) {
+    console.log(pc.bold(pc.yellow('Status: WARNING (Peringatan Kualitas, Hard Gate lolos)\n')))
+    process.exit(0)
+  } else {
+    console.log(pc.bold(pc.red('Status: FAILED (Gagal Hard Gate, perbaiki sebelum serah terima)\n')))
+    process.exit(1)
+  }
+} catch (err) {
+  console.error(pc.red(`Error: ${err.message}`))
+  process.exit(1)
+}

package/bin/slop-mcp.mjs

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+/**
+ * Slop AI Indo - Server MCP Terpadu (slop-mcp)
+ * Protokol Model Context Protocol (MCP) standar via stdio.
+ * Mengekspos tool linter, kontras WCAG, validasi Delivery Gate, dan katalog aturan ke IDE.
+ */
+
+import readline from 'node:readline'
+import path from 'node:path'
+import { lintContent, lintPath, RULES } from '../lib/linter.mjs'
+
+const PROTOCOL_VERSION = '2024-11-05'
+const SERVER_NAME = 'slop-ai-indo-mcp'
+const SERVER_VERSION = '1.1.0'
+
+// --- WCAG CONTRAST ALGORITHM ---
+function channel(c) {
+  c = c / 255.0
+  return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4)
+}
+
+function relativeLuminance(hexColor) {
+  let h = hexColor.trim().replace(/^#/, '')
+  if (h.length === 3) h = h.split('').map((c) => c + c).join('')
+  const r = parseInt(h.slice(0, 2), 16)
+  const g = parseInt(h.slice(2, 4), 16)
+  const b = parseInt(h.slice(4, 6), 16)
+  return 0.2126 * channel(r) + 0.7152 * channel(g) + 0.0722 * channel(b)
+}
+
+export function computeContrast(fg, bg) {
+  try {
+    const l1 = relativeLuminance(fg)
+    const l2 = relativeLuminance(bg)
+    const lighter = Math.max(l1, l2)
+    const darker = Math.min(l1, l2)
+    const ratio = Math.round(((lighter + 0.05) / (darker + 0.05)) * 100) / 100
+
+    return {
+      foreground: fg,
+      background: bg,
+      ratio,
+      normalText: { threshold: 4.5, pass: ratio >= 4.5 },
+      largeText: { threshold: 3.0, pass: ratio >= 3.0 },
+      verdict: ratio >= 4.5 ? 'PASS (WCAG AA)' : ratio >= 3.0 ? 'PASS (Large Text Only)' : 'FAIL (Insufficient Contrast)',
+    }
+  } catch (err) {
+    throw new Error(`Invalid hex color input: ${err.message}`)
+  }
+}
+
+// --- DELIVERY GATE VALIDATOR ---
+export function validateDeliveryGate(report) {
+  const blocks = {
+    testedRules: /aturan\s+yang\s+diuji|\brules?\s+tested\b/i.test(report),
+    smokeTest: /smoke\s+test|uji\s+interaktif|click-through/i.test(report),
+    contrastAudit: /kontras|wcag|contrast/i.test(report),
+    verdict: /\b(?:PASS|FAIL|LULUS|GAGAL)\b/.test(report),
+  }
+
+  const missing = []
+  if (!blocks.testedRules) missing.push('Blok 1: Aturan yang Diuji (Daftar R-xx yang dipatuhi)')
+  if (!blocks.smokeTest) missing.push('Blok 2: Bukti Smoke Test Interaktif (Uji klik elemen/form)')
+  if (!blocks.contrastAudit) missing.push('Blok 3: Pemeriksaan Kontras WCAG')
+  if (!blocks.verdict) missing.push('Blok 4: Status Kelulusan (PASS/FAIL)')
+
+  return {
+    valid: missing.length === 0,
+    blocks,
+    missing,
+    verdict: missing.length === 0 ? 'VALID' : 'INVALID (Incomplete Delivery Gate)',
+  }
+}
+
+// --- MCP TOOL DEFINITIONS ---
+const TOOLS = [
+  {
+    name: 'check_contrast',
+    description: 'Menghitung rasio kontras WCAG 2.1 antara dua warna heksadesimal (foreground & background) dan menentukan apakah memenuhi ambang batas AA.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        foreground: { type: 'string', description: 'Kode heksadesimal warna teks/foreground, misal: #0f172a' },
+        background: { type: 'string', description: 'Kode heksadesimal warna latar/background, misal: #ffffff' },
+      },
+      required: ['foreground', 'background'],
+    },
+  },
+  {
+    name: 'lint_snippet',
+    description: 'Memeriksa potongan kode atau teks secara instan dari AI slop (hype marketing, transition-all, pill button, komentar hampa, placeholder malas).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        code: { type: 'string', description: 'Konten kode atau teks yang ingin diperiksa' },
+        filename: { type: 'string', description: 'Nama berkas indikatif untuk deteksi ekstensi, misal: Button.tsx atau page.blade.php', default: 'snippet.html' },
+      },
+      required: ['code'],
+    },
+  },
+  {
+    name: 'lint_file',
+    description: 'Menjalankan linter deterministik terhadap berkas atau direktori di komputer lokal.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        targetPath: { type: 'string', description: 'Path absolut atau relatif ke file atau folder yang ingin diperiksa' },
+        tier: { type: 'string', description: 'Filter tingkat keparahan: all, hard-gate, atau quality-lock', default: 'all' },
+      },
+      required: ['targetPath'],
+    },
+  },
+  {
+    name: 'validate_delivery_gate',
+    description: 'Memvalidasi kelengkapan 4 blok wajib laporan Delivery Gate sebelum kode diserahkan ke pengguna.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        report: { type: 'string', description: 'Teks laporan evaluasi Delivery Gate yang dibuat agen' },
+      },
+      required: ['report'],
+    },
+  },
+  {
+    name: 'get_rule',
+    description: 'Mengambil informasi lengkap, alasan, dan solusi perbaikan dari suatu aturan slop-ai-indo berdasarkan Rule ID (misal: R-01, R-09, R-12, B-01, T-01).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        ruleId: { type: 'string', description: 'Kode nomor aturan, misal: R-09 atau R-12' },
+      },
+      required: ['ruleId'],
+    },
+  },
+]
+
+// --- JSON-RPC STDIO TRANSPORT ---
+function send(msg) {
+  process.stdout.write(JSON.stringify(msg) + '\n')
+}
+
+function reply(id, result) {
+  send({ jsonrpc: '2.0', id, result })
+}
+
+function error(id, code, message) {
+  send({ jsonrpc: '2.0', id, error: { code, message } })
+}
+
+export function handleToolCall(name, args = {}) {
+  switch (name) {
+    case 'check_contrast': {
+      const { foreground, background } = args
+      if (!foreground || !background) throw new Error('Parameter foreground dan background wajib diisi.')
+      const res = computeContrast(foreground, background)
+      return {
+        content: [{ type: 'text', text: JSON.stringify(res, null, 2) }],
+      }
+    }
+
+    case 'lint_snippet': {
+      const { code, filename = 'snippet.html' } = args
+      if (typeof code !== 'string') throw new Error('Parameter code wajib diisi.')
+      const findings = lintContent(code, filename)
+      const passed = findings.filter((f) => f.tier === 'Hard Gate').length === 0
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            passed,
+            totalFindings: findings.length,
+            findings,
+          }, null, 2),
+        }],
+      }
+    }
+
+    case 'lint_file': {
+      const { targetPath, tier = 'all' } = args
+      if (!targetPath) throw new Error('Parameter targetPath wajib diisi.')
+      const resolved = path.resolve(process.cwd(), targetPath)
+      const res = lintPath(resolved, { tier })
+      return {
+        content: [{ type: 'text', text: JSON.stringify(res, null, 2) }],
+      }
+    }
+
+    case 'validate_delivery_gate': {
+      const { report } = args
+      if (!report) throw new Error('Parameter report wajib diisi.')
+      const res = validateDeliveryGate(report)
+      return {
+        content: [{ type: 'text', text: JSON.stringify(res, null, 2) }],
+      }
+    }
+
+    case 'get_rule': {
+      const { ruleId } = args
+      if (!ruleId) throw new Error('Parameter ruleId wajib diisi.')
+      const normalized = ruleId.trim().toUpperCase()
+      const matched = Object.values(RULES).filter((r) => r.id === normalized)
+      if (matched.length === 0) {
+        return {
+          content: [{ type: 'text', text: `Aturan dengan ID "${ruleId}" tidak ditemukan dalam katalog linter.` }],
+          isError: true,
+        }
+      }
+      return {
+        content: [{ type: 'text', text: JSON.stringify(matched, null, 2) }],
+      }
+    }
+
+    default:
+      throw new Error(`Tool "${name}" tidak dikenal.`)
+  }
+}
+
+export function startMcpServer() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false,
+  })
+
+  rl.on('line', (line) => {
+    const trimmed = line.trim()
+    if (!trimmed) return
+
+    let msg
+    try {
+      msg = JSON.parse(trimmed)
+    } catch {
+      return
+    }
+
+    const { id, method, params } = msg
+
+    if (method === 'initialize') {
+      reply(id, {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: { tools: {} },
+        serverInfo: { name: SERVER_NAME, version: SERVER_VERSION },
+      })
+    } else if (method === 'notifications/initialized') {
+      // Client ready
+    } else if (method === 'ping') {
+      reply(id, {})
+    } else if (method === 'tools/list') {
+      reply(id, { tools: TOOLS })
+    } else if (method === 'tools/call') {
+      const { name, arguments: toolArgs } = params || {}
+      try {
+        const result = handleToolCall(name, toolArgs)
+        reply(id, result)
+      } catch (err) {
+        reply(id, {
+          content: [{ type: 'text', text: `Error executing ${name}: ${err.message}` }],
+          isError: true,
+        })
+      }
+    } else {
+      if (id !== undefined) {
+        error(id, -32601, `Method not found: ${method}`)
+      }
+    }
+  })
+
+  process.stderr.write(`${SERVER_NAME} v${SERVER_VERSION} listening on stdio\n`)
+}
+
+// Run directly if invoked via CLI
+if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/, '$1'))) {
+  startMcpServer()
+}

package/index.mjs

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
-import path from 'node:path'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
 import pc from 'picocolors'
 import { intro, outro, select, multiselect, confirm, isCancel, cancel, log, spinner } from '@clack/prompts'
 import { banner } from './lib/banner.mjs'
@@ -16,7 +19,8 @@ import {
   installedVersion,
   updateAll,
   updatePointers,
-  VERSION,
+  VERSION,
+  DESIGN_PRESETS,
 } from './lib/install.mjs'
 
 const EXTRA_SKILLS = [
@@ -27,7 +31,9 @@ const EXTRA_SKILLS = [
   { value: 'slop-ai-indo-code', label: 'slop-ai-indo-code', hint: 'code comment rules' },
   { value: 'slop-ai-indo-security', label: 'slop-ai-indo-security', hint: 'deep security audit and vulnerability review' },
   { value: 'slop-ai-indo-docs', label: 'slop-ai-indo-docs', hint: 'technical documentation, README, and API hygiene' },
-  { value: 'slop-ai-indo-identity', label: 'slop-ai-indo-identity', hint: 'brand identity, visual character, and anti-cloning' },
+  { value: 'slop-ai-indo-identity', label: 'slop-ai-indo-identity', hint: 'brand identity, visual character, and anti-cloning' },
+  { value: 'slop-ai-indo-backend', label: 'slop-ai-indo-backend', hint: 'backend architecture, API, and database hygiene' },
+  { value: 'slop-ai-indo-test', label: 'slop-ai-indo-test', hint: 'testing rules, anti-fake test and mock hygiene' },
 ]
 
 function stop(message) {
@@ -52,7 +58,42 @@ function printPluginDoors(found) {
   }
 }
 
-async function main() {
+async function main() {
+  if (process.argv[2] === 'lint' || process.argv.includes('--lint')) {
+    const { spawnSync } = await import('node:child_process')
+    const lintBin = path.join(__dirname, 'bin', 'slop-lint.mjs')
+    const lintArgs = process.argv.slice(2).filter((a) => a !== 'lint' && a !== '--lint')
+    const res = spawnSync(process.execPath, [lintBin, ...lintArgs], { stdio: 'inherit' })
+    process.exit(res.status ?? 0)
+  }
+
+  if (process.argv[2] === 'mcp' || process.argv.includes('--mcp')) {
+    const { spawnSync } = await import('node:child_process')
+    const mcpBin = path.join(__dirname, 'bin', 'slop-mcp.mjs')
+    const res = spawnSync(process.execPath, [mcpBin], { stdio: 'inherit' })
+    process.exit(res.status ?? 0)
+  }
+
+  if (process.argv[2] === 'hook' || process.argv.includes('--hook')) {
+    const { installGitHook, runPreCommitHook } = await import('./lib/hook.mjs')
+    if (process.argv.includes('--run')) {
+      const exitCode = runPreCommitHook()
+      process.exit(exitCode)
+    } else {
+      try {
+        const file = installGitHook(process.cwd())
+        console.log(pc.green('✔ Git pre-commit hook berhasil dipasang: ') + pc.dim(file))
+        console.log(pc.cyan('Setiap kali Anda menjalankan `git commit`, slop-lint akan otomatis memvalidasi staged files.'))
+        process.exit(0)
+      } catch (err) {
+        console.error(pc.red(`Gagal memasang hook: ${err.message}`))
+        process.exit(1)
+      }
+    }
+  }
+
+
+
   if (process.argv.includes('--version') || process.argv.includes('-v')) {
     console.log(`slop-ai-indo ${VERSION}`)
     return
@@ -115,6 +156,18 @@ async function main() {
   })
   if (isCancel(location)) stop('Install cancelled.')
 
+  let chosenPreset = 'enterprise'
+  if (location === 'project') {
+    log.step('Pilih Preset Desain (DESIGN.md)')
+    const preset = await select({
+      message: 'Pilih arah visual dan standar estetika untuk proyek ini:',
+      options: DESIGN_PRESETS,
+      initialValue: 'enterprise',
+    })
+    if (isCancel(preset)) stop('Install cancelled.')
+    chosenPreset = preset
+  }
+
   log.step('Choose which agents get antislop')
   const detected = detectAgents(location)
   const chosen = await multiselect({
@@ -164,7 +217,7 @@ async function main() {
   const spin = spinner()
   spin.start('Installing skills...')
   const written = installSkills({ skills, targets, overwrite })
-  const pointers = location === 'project' ? updatePointers({ targets, skills }) : []
+  const pointers = location === 'project' ? updatePointers({ targets, skills, designPreset: chosenPreset }) : []
   spin.stop('Done.')
 
   if (pointers.length > 0) {

package/lib/banner.mjs

@@ -15,7 +15,7 @@ export function banner() {
     ...LOGO,
     '',
     '  ' + pc.dim('Slop AI Indo: Rules for AI Coding Agents'),
-    '  ' + pc.dim('installer v1.0.2'),
+    '  ' + pc.dim('installer v1.2.0'),
     '',
   ].join('\n')
 }

package/lib/hook.mjs

@@ -0,0 +1,128 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { execSync } from 'node:child_process'
+import pc from 'picocolors'
+import { lintContent } from '../lib/linter.mjs'
+
+/**
+ * Memeriksa apakah path berkas harus dikecualikan dari audit hook.
+ */
+function shouldIgnoreHookFile(filePath) {
+  const norm = filePath.replace(/\\/g, '/')
+  const base = path.basename(norm)
+
+  // Abaikan folder dependensi, konfigurasi agen, artefak build, dan internal dev tools
+  if (/(?:^|\/)(node_modules|\.git|\.agents|\.claude|\.cursor|\.codex|\.opencode|\.cline|\.gemini|vendor|coverage|\.next|\.nuxt|dist|build|scripts|presets|skills)(?:\/|$)/i.test(norm)) {
+    return true
+  }
+
+  // Abaikan berkas test fixtures
+  if (/\.(?:test|spec)\.[a-z0-9]+$/i.test(base) || /^test-[^/]+\.(?:mjs|js|ts)$/i.test(base)) {
+    return true
+  }
+
+  // Abaikan berkas dokumentasi internal repositori aturan itu sendiri
+  if (['README.md', 'PRD.md', 'GUIDE.md', 'WORKFLOW.md', 'ROADMAP.md', 'DESIGN.md', 'slop-ai-indo.md'].includes(base)) {
+    return true
+  }
+
+  return false
+}
+
+/**
+ * Memasang git pre-commit hook ke dalam repositori target.
+ */
+export function installGitHook(targetDir = process.cwd()) {
+  const gitDir = path.join(targetDir, '.git')
+  if (!fs.existsSync(gitDir) || !fs.statSync(gitDir).isDirectory()) {
+    throw new Error(`Direktori "${targetDir}" bukan repositori Git (.git tidak ditemukan).`)
+  }
+
+  const hooksDir = path.join(gitDir, 'hooks')
+  fs.mkdirSync(hooksDir, { recursive: true })
+
+  const hookFile = path.join(hooksDir, 'pre-commit')
+  const hookScript = `#!/bin/sh
+# Slop AI Indo - Git Pre-commit Hook
+# Memverifikasi staged files sebelum commit diizinkan.
+
+if [ "$SLOP_SKIP_HOOK" = "1" ]; then
+  exit 0
+fi
+
+# Prioritaskan binary lokal repositori agar instan tanpa download
+if [ -f "./cli/index.mjs" ]; then
+  node ./cli/index.mjs hook --run
+elif [ -f "./node_modules/slop-ai-indo/index.mjs" ]; then
+  node ./node_modules/slop-ai-indo/index.mjs hook --run
+else
+  npx slop-ai-indo hook --run
+fi
+exit $?
+`
+
+  fs.writeFileSync(hookFile, hookScript, { mode: 0o755 })
+  return hookFile
+}
+
+/**
+ * Menjalankan inspeksi linter terhadap berkas yang sedang di-stage (git index).
+ */
+export function runPreCommitHook() {
+  let staged = []
+  try {
+    const raw = execSync('git diff --cached --name-only --diff-filter=ACM', { encoding: 'utf8' })
+    staged = raw.split(/\r?\n/).map((f) => f.trim()).filter(Boolean)
+  } catch {
+    // Bukan lingkungan git atau git command tidak ditemukan
+    return 0
+  }
+
+  if (staged.length === 0) {
+    return 0
+  }
+
+  const filesToCheck = staged.filter((file) => !shouldIgnoreHookFile(file))
+
+  if (filesToCheck.length === 0) {
+    return 0
+  }
+
+  console.log(pc.cyan(`🔍 [slop-hook] Memeriksa ${filesToCheck.length} staged file(s) sebelum commit...`))
+
+  let hardGateCount = 0
+  const findings = []
+
+  for (const file of filesToCheck) {
+    const fullPath = path.resolve(process.cwd(), file)
+    if (!fs.existsSync(fullPath)) continue
+    try {
+      const content = fs.readFileSync(fullPath, 'utf8')
+      const fileFindings = lintContent(content, fullPath)
+      const hardGates = fileFindings.filter((f) => f.tier === 'Hard Gate')
+      if (hardGates.length > 0) {
+        hardGateCount += hardGates.length
+        findings.push({ file, hardGates })
+      }
+    } catch {
+      // Abaikan berkas biner tak terbaca
+    }
+  }
+
+  if (hardGateCount > 0) {
+    console.error(pc.bold(pc.red(`\n❌ [slop-hook] Commit Ditolak! Ditemukan ${hardGateCount} pelanggaran Hard Gate:`)))
+    for (const f of findings) {
+      console.error(pc.bold(pc.underline(`\n${f.file}`)))
+      for (const item of f.hardGates) {
+        console.error(`  baris ${item.line} ${pc.red(`[${item.ruleId}]`)} ${item.name}`)
+        console.error(`    Kode: ${pc.dim(item.snippet)}`)
+        console.error(`    Solusi: ${pc.cyan(item.fix)}`)
+      }
+    }
+    console.error(pc.dim('\nPerbaiki pelanggaran di atas sebelum commit, atau gunakan `git commit --no-verify` jika darurat.\n'))
+    return 1
+  }
+
+  console.log(pc.green(`✔ [slop-hook] ${filesToCheck.length} staged file(s) bersih dari slop. Commit diizinkan.\n`))
+  return 0
+}

package/lib/install.mjs

@@ -7,7 +7,15 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url))
 
 export const CORE = 'slop-ai-indo'
 
-export const VERSION = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8')).version
+export const VERSION = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8')).version
+
+export const DESIGN_PRESETS = [
+  { value: 'enterprise', label: 'Enterprise SaaS (Rekomendasi)', hint: 'Kanvas terang, radius 4-6px, presisi ala Linear / n8n' },
+  { value: 'dark-modern', label: 'Dark Modern', hint: 'Kanvas gelap matte obsidian, monokrom presisi ala Vercel / Supabase' },
+  { value: 'editorial', label: 'Editorial & Content', hint: 'Warm canvas, serif typography ala Substack / Stripe Press' },
+  { value: 'utilitarian', label: 'Utilitarian & Dense Data', hint: 'High-density grid, border tegas, tabular data ala Grafana' },
+  { value: 'default', label: 'Bawaan (Default)', hint: 'Gunakan standar DESIGN.md asli slop-ai-indo' },
+]
 
 /** The release an existing install came from, or null when it predates the VERSION file.
  * Nothing else on disk names it, so without this an update cannot tell the user what
@@ -253,7 +261,9 @@ const SKILL_LINES = {
   'slop-ai-indo-code': 'Code comments: `slop-ai-indo-code`',
   'slop-ai-indo-security': 'Security audit: `slop-ai-indo-security`',
   'slop-ai-indo-docs': 'Technical documentation: `slop-ai-indo-docs`',
-  'slop-ai-indo-identity': 'Brand & visual character: `slop-ai-indo-identity`',
+  'slop-ai-indo-identity': 'Brand & visual character: `slop-ai-indo-identity`',
+  'slop-ai-indo-backend': 'Backend & API: `slop-ai-indo-backend`',
+  'slop-ai-indo-test': 'Testing & mocks: `slop-ai-indo-test`',
 }
 
 export const SKILL_NAMES = Object.keys(SKILL_LINES)
@@ -342,22 +352,31 @@ function writeBlock(entry, block) {
   fs.writeFileSync(entry, body + eol)
 }
 
-export function updatePointers({ targets, skills }) {
-  const entries = new Set()
-  for (const t of targets) {
-    if (fs.existsSync(path.join(t.path, CORE))) for (const a of t.agents) entries.add(a.entry)
-  }
-
-  // Copy DESIGN.md and slop-ai-indo.md into current project if bundled
-  const bundledDesign = path.join(__dirname, '..', 'DESIGN.md')
-  if (fs.existsSync(bundledDesign)) {
-    fs.copyFileSync(bundledDesign, path.join(process.cwd(), 'DESIGN.md'))
-  }
-  const bundledSlop = path.join(__dirname, '..', 'slop-ai-indo.md')
-  if (fs.existsSync(bundledSlop)) {
-    fs.copyFileSync(bundledSlop, path.join(process.cwd(), 'slop-ai-indo.md'))
-  }
-
+export function updatePointers({ targets, skills, designPreset = 'enterprise' } = {}) {
+  const entries = new Set()
+  for (const t of targets) {
+    if (fs.existsSync(path.join(t.path, CORE))) for (const a of t.agents) entries.add(a.entry)
+  }
+
+  // Copy chosen DESIGN.md preset and slop-ai-indo.md into current project if bundled
+  const presetFile = `${designPreset}.md`
+  const bundledPreset = path.join(__dirname, '..', 'presets', presetFile)
+  const repoPreset = path.join(__dirname, '..', '..', 'presets', presetFile)
+  const bundledDesign = path.join(__dirname, '..', 'DESIGN.md')
+
+  let sourceDesign = null
+  if (fs.existsSync(bundledPreset)) sourceDesign = bundledPreset
+  else if (fs.existsSync(repoPreset)) sourceDesign = repoPreset
+  else if (fs.existsSync(bundledDesign)) sourceDesign = bundledDesign
+
+  if (sourceDesign) {
+    fs.copyFileSync(sourceDesign, path.join(process.cwd(), 'DESIGN.md'))
+  }
+  const bundledSlop = path.join(__dirname, '..', 'slop-ai-indo.md')
+  if (fs.existsSync(bundledSlop)) {
+    fs.copyFileSync(bundledSlop, path.join(process.cwd(), 'slop-ai-indo.md'))
+  }
+
   const block = pointerBlock(skills)
   const written = []
   for (const name of entries) {