@ngocsangairvds/vsaf 3.0.0

package/assets/templates/scripts/session-end-check.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# Session-end verification hook for Claude Code.
+# Checks staged files for secrets and debug artifacts.
+set -euo pipefail
+
+cd "${PROJECT_DIR:-.}" 2>/dev/null || exit 0
+
+ISSUES=""
+
+# Check for hardcoded secrets in staged files
+SECRETS=$(git diff --cached --diff-filter=ACM --name-only 2>/dev/null \
+  | xargs grep -lE 'AKIA[0-9A-Z]{16}|ghp_[a-zA-Z0-9]{36}|sk-[a-zA-Z0-9]{48}|xox[bpoas]-|BEGIN.*PRIVATE' 2>/dev/null) || true
+
+if [ -n "$SECRETS" ]; then
+  ISSUES="${ISSUES}WARNING: Possible secrets staged: ${SECRETS} "
+fi
+
+# Check for debug artifacts in staged files
+LOGS=$(git diff --cached --name-only 2>/dev/null \
+  | xargs grep -lE 'console[.]log|debugger' 2>/dev/null) || true
+
+if [ -n "$LOGS" ]; then
+  ISSUES="${ISSUES}WARNING: Debug artifacts in staged files: ${LOGS} "
+fi
+
+if [ -n "$ISSUES" ]; then
+  echo "$ISSUES"
+fi

package/bin/vsaf.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+'use strict';
+
+const [,, cmd] = process.argv;
+
+const HELP = `
+vsaf — Agentic AI SDLC Framework v3
+
+USAGE
+  vsaf init       Full setup: global infra + project scaffold
+  vsaf global     Install global infra only  (skills, binaries)
+  vsaf project    Scaffold project files only (assumes global done)
+  vsaf status     Show installation status
+
+GLOBAL  (once per machine → ~/.claude/)
+  Skills  : bmad (41), openspec (4), vsaf (5), gitnexus (6)
+  Binaries: gitnexus, openspec, graphify, mempalace, bun, claude-mem
+
+PER PROJECT  (per repo, run inside the repo root)
+  .claude/settings.json   Hooks: secret detection, protected files
+  CLAUDE.md               10-step workflow rules
+  Makefile                index, verify, review, archive, mine, status
+  scripts/                Session-end check hook
+
+EXAMPLES
+  npx vsaf init           # New machine + new project (recommended)
+  npx vsaf global         # Already have projects, new machine
+  npx vsaf project        # Global already done, add VSAF to existing repo
+  npx vsaf status         # Check what is installed
+`;
+
+async function main() {
+  switch (cmd) {
+    case 'init': {
+      const { installGlobal } = require('../src/global');
+      const { installProject } = require('../src/project');
+      await installGlobal();
+      await installProject();
+      break;
+    }
+    case 'global': {
+      const { installGlobal } = require('../src/global');
+      await installGlobal();
+      break;
+    }
+    case 'project': {
+      const { installProject } = require('../src/project');
+      await installProject();
+      break;
+    }
+    case 'status': {
+      const { showStatus } = require('../src/status');
+      await showStatus();
+      break;
+    }
+    default:
+      console.log(HELP);
+      if (cmd && cmd !== '--help' && cmd !== 'help') {
+        console.error(`\nUnknown command: ${cmd}`);
+        process.exit(1);
+      }
+  }
+}
+
+main().catch(err => {
+  console.error('\x1b[31mError:\x1b[0m', err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@ngocsangairvds/vsaf",
+  "version": "3.0.0",
+  "description": "VSAF — Agentic AI SDLC Framework. Spec-driven development, 3-layer review, 7 integrated tools.",
+  "keywords": ["claude", "claude-code", "ai", "sdlc", "framework", "bmad", "openspec"],
+  "bin": {
+    "vsaf": "./bin/vsaf.js"
+  },
+  "scripts": {
+    "test": "echo 'No tests'"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    ".claude/skills/",
+    "assets/"
+  ],
+  "license": "MIT"
+}

package/src/global.js

@@ -0,0 +1,98 @@
+'use strict';
+const path = require('path');
+const fs = require('fs');
+const { ok, info, warn, step, hasCommand, exec, copyDir, copyFile, CLAUDE_HOME } = require('./utils');
+
+const PKG_ROOT   = path.join(__dirname, '..');
+const SKILLS_SRC = path.join(PKG_ROOT, '.claude', 'skills');
+const SKILLS_DST = path.join(CLAUDE_HOME, 'skills');
+
+async function installGlobal() {
+  console.log('\n\x1b[1m╔══════════════════════════════════════════╗\x1b[0m');
+  console.log(  '\x1b[1m║   VSAF — Global Infra                    ║\x1b[0m');
+  console.log(  '\x1b[1m╚══════════════════════════════════════════╝\x1b[0m');
+
+  installSkills();
+  installBinary('gitnexus',  () => exec('npm install -g gitnexus'));
+  installBinary('openspec',  () => exec('npm install -g @fission-ai/openspec@latest'));
+  installPipx('graphify',   'graphifyy');
+  installPipx('mempalace',  'mempalace');
+  installBun();
+  installClaudeMem();
+
+  console.log('\n\x1b[32m\x1b[1m✓ Global infra ready.\x1b[0m\n');
+}
+
+// ── Skills ──────────────────────────────────────────────────────────────────
+
+function installSkills() {
+  step('Skills → ~/.claude/skills/');
+
+  if (!fs.existsSync(SKILLS_SRC)) {
+    warn('Skills directory not found in package — skipping');
+    return;
+  }
+
+  fs.mkdirSync(SKILLS_DST, { recursive: true });
+
+  let installed = 0;
+  let skipped   = 0;
+
+  for (const entry of fs.readdirSync(SKILLS_SRC, { withFileTypes: true })) {
+    const src = path.join(SKILLS_SRC, entry.name);
+    const dst = path.join(SKILLS_DST, entry.name);
+
+    if (fs.existsSync(dst)) {
+      skipped++;
+      continue;
+    }
+
+    entry.isDirectory() ? copyDir(src, dst) : copyFile(src, dst);
+    installed++;
+  }
+
+  ok(`${installed} skill(s) installed, ${skipped} already present`);
+}
+
+// ── Binary helpers ───────────────────────────────────────────────────────────
+
+function installBinary(name, installFn) {
+  step(`${name}`);
+  if (hasCommand(name)) { ok(`${name} already installed`); return; }
+  info(`Installing ${name}...`);
+  installFn()
+    ? ok(`${name} installed`)
+    : warn(`${name} install failed — run manually`);
+}
+
+function installPipx(cmd, pkg) {
+  step(cmd);
+  if (hasCommand(cmd)) { ok(`${cmd} already installed`); return; }
+  if (!hasCommand('pipx')) {
+    warn(`pipx not found — install pipx first, then run: pipx install ${pkg}`);
+    return;
+  }
+  info(`Installing ${pkg} via pipx...`);
+  exec(`pipx install ${pkg}`)
+    ? ok(`${cmd} installed`)
+    : warn(`${cmd} install failed — run: pipx install ${pkg}`);
+}
+
+function installBun() {
+  step('bun (claude-mem runtime)');
+  if (hasCommand('bun')) { ok('bun already installed'); return; }
+  info('Installing bun...');
+  exec('curl -fsSL https://bun.sh/install | bash')
+    ? ok('bun installed')
+    : warn('bun install failed — run: curl -fsSL https://bun.sh/install | bash');
+}
+
+function installClaudeMem() {
+  step('claude-mem');
+  info('Running claude-mem install...');
+  exec('npx claude-mem install')
+    ? ok('claude-mem installed')
+    : warn('claude-mem install had issues — check manually');
+}
+
+module.exports = { installGlobal };

package/src/project.js

@@ -0,0 +1,94 @@
+'use strict';
+const path = require('path');
+const fs   = require('fs');
+const { ok, info, warn, step, hasCommand, exec, copyDir, copyFile } = require('./utils');
+
+const PKG_ROOT  = path.join(__dirname, '..');
+const TEMPLATES = path.join(PKG_ROOT, 'assets', 'templates');
+const CWD       = process.cwd();
+
+async function installProject() {
+  console.log('\n\x1b[1m╔══════════════════════════════════════════╗\x1b[0m');
+  console.log(  '\x1b[1m║   VSAF — Project Scaffold                ║\x1b[0m');
+  console.log(  '\x1b[1m╚══════════════════════════════════════════╝\x1b[0m');
+
+  scaffoldFiles();
+  initOpenSpec();
+  initGitNexus();
+  initMemPalace();
+  configureGitHooks();
+
+  console.log('\n\x1b[32m\x1b[1m✓ Project ready.\x1b[0m');
+  console.log('\n  Next steps:');
+  console.log('    make status         check all tools');
+  console.log('    /graphify .         build knowledge graph (inside Claude Code)');
+  console.log('    /superpowers install install Superpowers plugin (inside Claude Code)\n');
+}
+
+// ── File scaffold ────────────────────────────────────────────────────────────
+
+function scaffoldFiles() {
+  step('Scaffolding project files');
+
+  const files = [
+    { tpl: '.claude/settings.json', dst: '.claude/settings.json' },
+    { tpl: 'CLAUDE.md',             dst: 'CLAUDE.md'             },
+    { tpl: 'Makefile',              dst: 'Makefile'               },
+    { tpl: 'scripts/session-end-check.sh', dst: 'scripts/session-end-check.sh', chmod: 0o755 },
+  ];
+
+  for (const { tpl, dst, chmod } of files) {
+    const src    = path.join(TEMPLATES, tpl);
+    const dstAbs = path.join(CWD, dst);
+
+    if (!fs.existsSync(src)) {
+      warn(`Template missing: ${tpl}`);
+      continue;
+    }
+
+    if (fs.existsSync(dstAbs)) {
+      ok(`${dst} — already exists, skipped`);
+    } else {
+      copyFile(src, dstAbs);
+      if (chmod) fs.chmodSync(dstAbs, chmod);
+      ok(`${dst} — created`);
+    }
+  }
+}
+
+// ── Tool initialisation ──────────────────────────────────────────────────────
+
+function initOpenSpec() {
+  step('OpenSpec');
+  if (!hasCommand('openspec')) { warn('openspec not found — run: vsaf global'); return; }
+  const already = fs.existsSync(path.join(CWD, 'openspec.json'))
+               || fs.existsSync(path.join(CWD, 'openspec'));
+  if (already) { ok('OpenSpec already initialised'); return; }
+  info('Initialising openspec...');
+  exec('openspec init', { cwd: CWD }) ? ok('OpenSpec initialised') : warn('openspec init failed — run manually');
+}
+
+function initGitNexus() {
+  step('GitNexus');
+  if (!hasCommand('gitnexus')) { warn('gitnexus not found — run: vsaf global'); return; }
+  info('Indexing repository (gitnexus analyze)...');
+  exec('gitnexus analyze', { cwd: CWD }) ? ok('Repository indexed') : warn('gitnexus analyze failed — run manually');
+}
+
+function initMemPalace() {
+  step('MemPalace');
+  if (!hasCommand('mempalace')) { warn('mempalace not found — run: vsaf global'); return; }
+  if (fs.existsSync(path.join(CWD, 'mempalace.yaml'))) { ok('MemPalace already initialised'); return; }
+  info('Initialising mempalace...');
+  exec(`mempalace init --yes "${CWD}"`, { cwd: CWD }) ? ok('MemPalace initialised') : warn('mempalace init failed — run manually');
+}
+
+function configureGitHooks() {
+  step('Git hooks');
+  if (!fs.existsSync(path.join(CWD, '.git'))) { warn('Not a git repo — skipping'); return; }
+  fs.mkdirSync(path.join(CWD, 'githooks'), { recursive: true });
+  exec('git config core.hooksPath githooks/', { cwd: CWD });
+  ok('Git hooks path → githooks/');
+}
+
+module.exports = { installProject };

package/src/status.js

@@ -0,0 +1,51 @@
+'use strict';
+const path = require('path');
+const fs   = require('fs');
+const { hasCommand, CLAUDE_HOME } = require('./utils');
+
+async function showStatus() {
+  console.log('\n\x1b[1mVSAF Status\x1b[0m\n');
+
+  // ── Global ─────────────────────────────────────────────────────────────────
+  console.log('\x1b[1mGlobal  (machine-wide → ~/.claude/)\x1b[0m');
+  checkSkills();
+  checkCmd('gitnexus',  'GitNexus');
+  checkCmd('openspec',  'OpenSpec');
+  checkCmd('graphify',  'Graphify');
+  checkCmd('mempalace', 'MemPalace');
+  checkCmd('bun',       'Bun');
+
+  // ── Project ────────────────────────────────────────────────────────────────
+  console.log('\n\x1b[1mProject  (current repo)\x1b[0m');
+  checkPath('.claude/settings.json', 'Project settings');
+  checkPath('CLAUDE.md',             'Workflow rules');
+  checkPath('Makefile',              'Makefile');
+  checkPath('scripts/session-end-check.sh', 'Session-end hook');
+  checkPath('.gitnexus',             'GitNexus index');
+  checkPath('openspec',              'OpenSpec');
+  checkPath('mempalace.yaml',        'MemPalace');
+  checkPath('githooks',              'Git hooks');
+  console.log('');
+}
+
+function checkCmd(cmd, label) {
+  const found = hasCommand(cmd);
+  console.log(`  ${found ? '\x1b[32m✓\x1b[0m' : '\x1b[31m✗\x1b[0m'} ${label}`);
+}
+
+function checkSkills() {
+  const dir = path.join(CLAUDE_HOME, 'skills');
+  if (!fs.existsSync(dir)) {
+    console.log('  \x1b[31m✗\x1b[0m Skills (not installed)');
+    return;
+  }
+  const count = fs.readdirSync(dir).length;
+  console.log(`  \x1b[32m✓\x1b[0m Skills (${count} in ~/.claude/skills/)`);
+}
+
+function checkPath(rel, label) {
+  const exists = fs.existsSync(path.join(process.cwd(), rel));
+  console.log(`  ${exists ? '\x1b[32m✓\x1b[0m' : '\x1b[31m✗\x1b[0m'} ${label}`);
+}
+
+module.exports = { showStatus };

package/src/utils.js

@@ -0,0 +1,42 @@
+'use strict';
+const { execSync, spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CLAUDE_HOME = path.join(os.homedir(), '.claude');
+
+const ok   = (msg) => console.log(`  \x1b[32m✓\x1b[0m ${msg}`);
+const info = (msg) => console.log(`  \x1b[36m→\x1b[0m ${msg}`);
+const warn = (msg) => console.log(`  \x1b[33m!\x1b[0m ${msg}`);
+const step = (msg) => console.log(`\n\x1b[1m${msg}\x1b[0m`);
+
+function hasCommand(cmd) {
+  const r = spawnSync(cmd, ['--version'], { stdio: 'ignore', shell: false });
+  return r.status === 0;
+}
+
+function exec(cmd, opts = {}) {
+  try {
+    execSync(cmd, { stdio: opts.silent ? 'pipe' : 'inherit', shell: true, ...opts });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function copyDir(src, dst) {
+  fs.mkdirSync(dst, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, entry.name);
+    const d = path.join(dst, entry.name);
+    entry.isDirectory() ? copyDir(s, d) : fs.copyFileSync(s, d);
+  }
+}
+
+function copyFile(src, dst) {
+  fs.mkdirSync(path.dirname(dst), { recursive: true });
+  fs.copyFileSync(src, dst);
+}
+
+module.exports = { ok, info, warn, step, hasCommand, exec, copyDir, copyFile, CLAUDE_HOME };