@quybt93/pcgf 0.0.1

package/installer/cli.js

@@ -0,0 +1,479 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { runClean } from './clean.js';
+import { inspectProjectDeps } from './deps.js';
+import { readExistingManifest, runInstall } from './install.js';
+import { INSTALL_DIR_NAME, packageRoot, pluginRoot } from './paths.js';
+import { listSkillNames, pathExists, readJson } from './fs-utils.js';
+import { TOOL_IDS, formatToolsHelp, parseTools } from './tools.js';
+
+const DEFAULT_TOOLS = ['cursor', 'codex'];
+
+function printHelp() {
+  const version = readJson(path.join(packageRoot, 'package.json'), { version: '0.0.0' }).version;
+  console.log(`pcgf v${version} — Phaser Casual Game Factory
+
+BMAD-style installer. From your game project folder:
+
+  npx pcgf install
+
+Installs into the current directory with defaults:
+  tools = cursor,codex
+  scaffold = on
+
+If phaser/rxjs are missing, asks once to confirm npm install.
+Use --yes to auto-confirm that step.
+
+Commands:
+  install              Install plugin into the current project (default)
+  clean | uninstall    Remove _pcgf + factory Cursor/Codex hooks (reinstall-ready)
+  skills               List factory skills + short descriptions
+  help                 Show this help
+
+Options:
+  --directory <path>   Target project directory (default: cwd)
+  --tools <a,b>        Override tools: ${TOOL_IDS.join(', ')}
+  --scaffold           Force scaffold on (install) / with clean: also delete src/factory/
+  --no-scaffold        Skip foundation scaffold
+  --with-scaffold      Alias for clean --scaffold (delete src/factory/)
+  --install-deps       Install missing phaser/rxjs without asking
+  --no-install-deps    Do not install phaser/rxjs
+  --yes, -y            Auto-confirm dependency install / clean
+  --list-tools         Print supported tool IDs and exit
+  --list-skills        Same as: pcgf skills
+  --help, -h           Show help
+
+Examples:
+  npx pcgf install
+  npx pcgf install --yes
+  npx pcgf install --no-install-deps
+  npx pcgf install --tools cursor
+  npx pcgf clean --yes
+  npx pcgf clean --yes --with-scaffold
+  npx pcgf skills
+`);
+}
+
+function unwrapYamlScalar(value) {
+  const trimmed = value.trim();
+  if (
+    (trimmed.startsWith('"') && trimmed.endsWith('"'))
+    || (trimmed.startsWith("'") && trimmed.endsWith("'"))
+  ) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+
+function readSkillMeta(skillDir) {
+  const skillFile = path.join(skillDir, 'SKILL.md');
+  const folderName = path.basename(skillDir);
+  if (!pathExists(skillFile)) {
+    return { name: folderName, description: '(missing SKILL.md)' };
+  }
+
+  const text = fs.readFileSync(skillFile, 'utf8');
+  const nameMatch = text.match(/^name:\s*(.+)$/m);
+  const descriptionMatch = text.match(/^description:\s*(.+)$/m);
+  return {
+    name: nameMatch ? unwrapYamlScalar(nameMatch[1]) : folderName,
+    description: descriptionMatch
+      ? unwrapYamlScalar(descriptionMatch[1])
+      : '(no description)',
+  };
+}
+
+function resolveSkillsRoot(projectDir) {
+  const installed = path.join(projectDir, INSTALL_DIR_NAME, 'plugin', 'skills');
+  if (pathExists(installed)) {
+    return { root: installed, source: `_pcgf/plugin/skills` };
+  }
+
+  const packaged = path.join(pluginRoot, 'skills');
+  if (pathExists(packaged)) {
+    return { root: packaged, source: 'package plugins/.../skills' };
+  }
+
+  return null;
+}
+
+function printSkillsList(projectDir) {
+  const resolved = resolveSkillsRoot(projectDir);
+  if (!resolved) {
+    throw new Error(
+      'No skills found. Run from a project with _pcgf/, or from the factory package.',
+    );
+  }
+
+  const names = listSkillNames(resolved.root);
+  console.log(`pcgf skills (${names.length}) — ${resolved.source}`);
+  console.log('');
+  for (const [index, name] of names.entries()) {
+    const meta = readSkillMeta(path.join(resolved.root, name));
+    console.log(`${String(index + 1).padStart(2, ' ')}. ${meta.name}`);
+    console.log(`    ${meta.description}`);
+    if (index < names.length - 1) {
+      console.log('');
+    }
+  }
+}
+
+function parseArgs(argv) {
+  const options = {
+    command: null,
+    directory: process.cwd(),
+    tools: null,
+    scaffold: null,
+    withScaffold: false,
+    installDeps: null,
+    yes: false,
+    listTools: false,
+    listSkills: false,
+    help: false,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === 'install' || arg === 'skills' || arg === 'help' || arg === 'clean' || arg === 'uninstall') {
+      options.command = arg === 'uninstall' ? 'clean' : arg;
+      continue;
+    }
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+      continue;
+    }
+    if (arg === '--list-tools') {
+      options.listTools = true;
+      continue;
+    }
+    if (arg === '--list-skills') {
+      options.listSkills = true;
+      continue;
+    }
+    if (arg === '--yes' || arg === '-y') {
+      options.yes = true;
+      continue;
+    }
+    if (arg === '--scaffold') {
+      options.scaffold = true;
+      continue;
+    }
+    if (arg === '--no-scaffold') {
+      options.scaffold = false;
+      continue;
+    }
+    if (arg === '--with-scaffold') {
+      options.withScaffold = true;
+      continue;
+    }
+    if (arg === '--install-deps') {
+      options.installDeps = true;
+      continue;
+    }
+    if (arg === '--no-install-deps') {
+      options.installDeps = false;
+      continue;
+    }
+    if (arg === '--directory') {
+      const value = argv[i + 1];
+      if (!value || value.startsWith('-')) {
+        throw new Error('--directory requires a path');
+      }
+      options.directory = path.resolve(value);
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--directory=')) {
+      options.directory = path.resolve(arg.slice('--directory='.length));
+      continue;
+    }
+    if (arg === '--tools') {
+      const value = argv[i + 1];
+      if (!value || value.startsWith('-')) {
+        throw new Error('--tools requires a comma-separated list');
+      }
+      options.tools = parseTools(value);
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--tools=')) {
+      options.tools = parseTools(arg.slice('--tools='.length));
+      continue;
+    }
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return options;
+}
+
+async function promptYesNo(question, defaultYes = true) {
+  const rl = readline.createInterface({ input, output });
+  try {
+    const hint = defaultYes ? 'Y/n' : 'y/N';
+    const answer = (await rl.question(`${question} (${hint}): `)).trim().toLowerCase();
+    if (answer === '') {
+      return defaultYes;
+    }
+    return answer === 'y' || answer === 'yes';
+  } finally {
+    rl.close();
+  }
+}
+
+function resolveBaseOptions(parsed) {
+  const directory = path.resolve(parsed.directory);
+  const existing = readExistingManifest(directory);
+
+  if (existing) {
+    console.log(`Found existing ${INSTALL_DIR_NAME}/ (v${existing.version}). Refreshing...`);
+  }
+
+  const tools = parsed.tools && parsed.tools.length > 0
+    ? parsed.tools
+    : (existing?.tools?.length ? existing.tools : DEFAULT_TOOLS);
+
+  const scaffold = parsed.scaffold === null
+    ? (existing ? Boolean(existing.scaffold) : true)
+    : parsed.scaffold;
+
+  return {
+    directory,
+    tools,
+    scaffold,
+    yes: parsed.yes,
+    installDepsFlag: parsed.installDeps,
+  };
+}
+
+async function resolveDepsConfirmation(directory, { yes, installDepsFlag }) {
+  const inspection = inspectProjectDeps(directory);
+  if (inspection.missing.length === 0) {
+    console.log('Dependencies: phaser + rxjs already present.');
+    return false;
+  }
+
+  if (installDepsFlag === false) {
+    console.log(`Dependencies: missing ${inspection.missing.join(', ')} (skipped by --no-install-deps).`);
+    return false;
+  }
+
+  if (installDepsFlag === true || yes) {
+    console.log(`Dependencies: installing missing ${inspection.missing.join(', ')}...`);
+    return true;
+  }
+
+  if (!inspection.hasPackageJson) {
+    return promptYesNo(
+      'Project này chưa có package.json. Tạo mới và cài phaser + rxjs vào project ngay bây giờ?',
+      true,
+    );
+  }
+
+  return promptYesNo(
+    `Project này thiếu ${inspection.missing.join(', ')}. Thêm vào package.json và chạy npm install ngay?`,
+    true,
+  );
+}
+
+function pad(text, width) {
+  const value = String(text ?? '');
+  return value.length >= width ? value : `${value}${' '.repeat(width - value.length)}`;
+}
+
+function printInstalledTable(rows) {
+  const pathWidth = Math.max(4, ...rows.map((row) => row.path.length));
+  const descWidth = Math.max(8, ...rows.map((row) => row.desc.length));
+  const border = `+-${'-'.repeat(pathWidth)}-+-${'-'.repeat(descWidth)}-+`;
+
+  console.log(border);
+  console.log(`| ${pad('Path', pathWidth)} | ${pad('Nội dung', descWidth)} |`);
+  console.log(border);
+  for (const row of rows) {
+    console.log(`| ${pad(row.path, pathWidth)} | ${pad(row.desc, descWidth)} |`);
+  }
+  console.log(border);
+}
+
+function depsRow(depsResult) {
+  if (!depsResult) {
+    return null;
+  }
+  if (depsResult.status === 'already-present') {
+    return { path: 'phaser + rxjs', desc: 'Đã có sẵn trong project' };
+  }
+  if (depsResult.status === 'installed') {
+    const created = depsResult.createdPackageJson ? ' (đã tạo package.json)' : '';
+    return {
+      path: 'phaser + rxjs',
+      desc: `Đã cài bằng npm install${created}`,
+    };
+  }
+  if (depsResult.status === 'skipped' || depsResult.status === 'skipped-no-package-json') {
+    return {
+      path: 'phaser + rxjs',
+      desc: `Chưa cài — chạy: npm install ${depsResult.missing.join(' ')}`,
+    };
+  }
+  return { path: 'phaser + rxjs', desc: depsResult.status };
+}
+
+function buildInstalledRows(result) {
+  const skillCount = result.manifest.skills.length;
+  const rows = [
+    { path: '_pcgf/', desc: 'Bản copy plugin + manifest.json' },
+    { path: '_pcgf/plugin/skills/', desc: `${skillCount} skills cho AI (factory, loading, economy…)` },
+    { path: '_pcgf/plugin/templates/', desc: 'Template code tái sử dụng' },
+    { path: '_pcgf/plugin/references/', desc: 'Tài liệu contract' },
+  ];
+
+  if (result.toolResults.cursor) {
+    rows.push({
+      path: '.cursor/skills/',
+      desc: `${result.toolResults.cursor.skills.length} skills gắn vào Cursor`,
+    });
+  }
+  if (result.toolResults.codex) {
+    rows.push({
+      path: '.agents/plugins/marketplace.json',
+      desc: 'Marketplace local cho Codex',
+    });
+  }
+  if (result.scaffoldResult) {
+    rows.push(
+      { path: 'src/app/, src/core/, src/scenes/…', desc: 'Cấu trúc foundation' },
+      { path: 'src/factory/loading-view/', desc: 'LoadingView MVVM' },
+      { path: 'src/factory/boot/', desc: 'Optional Studio25 Boot View (opt-in)' },
+      { path: 'src/factory/phaser/', desc: 'Shared LoadingView overlay (Boot + scenes)' },
+      { path: 'public/assets/ui/', desc: 'Asset fallback (BG, mask)' },
+    );
+  }
+
+  const depRow = depsRow(result.depsResult);
+  if (depRow) {
+    rows.push(depRow);
+  }
+
+  return rows;
+}
+
+function printResult(result) {
+  console.log('');
+  console.log('Phaser Casual Game Factory is ready to use!');
+  console.log(`  Action:     ${result.action}`);
+  console.log(`  Project:    ${result.projectDir}`);
+  console.log(`  Version:    ${result.manifest.version}`);
+  console.log(`  Tools:      ${result.manifest.tools.join(', ') || '(none)'}`);
+  console.log(`  Scaffold:   ${result.manifest.scaffold ? 'yes' : 'no'}`);
+  console.log(`  Deps:       ${result.depsResult?.status || 'n/a'}`);
+  console.log('');
+  console.log('Đã cài những gì:');
+  printInstalledTable(buildInstalledRows(result));
+  console.log('');
+  console.log('Next: open the project and ask the agent to use skill phaser-casual-game-factory.');
+}
+
+function printCleanResult(result) {
+  console.log('');
+  if (!result.foundAnything) {
+    console.log('Nothing to clean — no _pcgf install artifacts found.');
+    console.log(`  Project: ${result.projectDir}`);
+    return;
+  }
+
+  console.log('PCGF install artifacts removed.');
+  console.log(`  Project: ${result.projectDir}`);
+  console.log(`  Scaffold src/factory/: ${result.withScaffold ? 'deleted' : 'kept'}`);
+  console.log('');
+  console.log('Removed:');
+  for (const item of result.removed) {
+    console.log(`  - ${item}`);
+  }
+  console.log('');
+  console.log('Reinstall clean:');
+  console.log('  npx pcgf install --yes --scaffold');
+  console.log('Or refresh skills only (keep src):');
+  console.log('  npx pcgf install --yes --no-scaffold');
+}
+
+async function runCleanCommand(parsed) {
+  const directory = path.resolve(parsed.directory);
+  const withScaffold = Boolean(parsed.withScaffold || parsed.scaffold === true);
+
+  const existing = readExistingManifest(directory);
+  const hasInstall = Boolean(existing) || pathExists(path.join(directory, INSTALL_DIR_NAME));
+  const hasFactory = pathExists(path.join(directory, 'src', 'factory'));
+
+  if (!hasInstall && !(withScaffold && hasFactory)) {
+    printCleanResult({
+      projectDir: directory,
+      withScaffold,
+      removed: [],
+      foundAnything: false,
+    });
+    return;
+  }
+
+  if (!parsed.yes) {
+    const scaffoldNote = withScaffold
+      ? ' + src/factory/'
+      : ' (giữ src/factory/ — thêm --with-scaffold nếu muốn xóa)';
+    const ok = await promptYesNo(
+      `Xóa ${INSTALL_DIR_NAME}/ + factory Cursor/Codex hooks${scaffoldNote}?`,
+      false,
+    );
+    if (!ok) {
+      console.log('Clean cancelled.');
+      return;
+    }
+  }
+
+  const result = runClean({ directory, withScaffold });
+  printCleanResult(result);
+}
+
+export async function runCli(argv) {
+  const parsed = parseArgs(argv);
+
+  if (parsed.help || parsed.command === 'help' || argv.length === 0) {
+    printHelp();
+    return;
+  }
+
+  if (parsed.listTools) {
+    console.log('Supported tools:');
+    console.log(formatToolsHelp());
+    return;
+  }
+
+  if (parsed.listSkills || parsed.command === 'skills') {
+    printSkillsList(path.resolve(parsed.directory));
+    return;
+  }
+
+  if (parsed.command === 'clean') {
+    await runCleanCommand(parsed);
+    return;
+  }
+
+  if (parsed.command !== 'install') {
+    throw new Error(
+      `Unknown command: ${parsed.command || '(none)'}. Try: pcgf install | pcgf clean | pcgf skills`,
+    );
+  }
+
+  const base = resolveBaseOptions(parsed);
+  const installDeps = await resolveDepsConfirmation(base.directory, {
+    yes: base.yes,
+    installDepsFlag: base.installDepsFlag,
+  });
+
+  const result = await runInstall({
+    directory: base.directory,
+    tools: base.tools,
+    scaffold: base.scaffold,
+    installDeps,
+  });
+  printResult(result);
+}

package/installer/deps.js

@@ -0,0 +1,160 @@
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { pathExists, readJson, writeJson } from './fs-utils.js';
+
+export const REQUIRED_DEPS = {
+  phaser: '^3.90.0',
+  rxjs: '^7.8.2',
+};
+
+export function inspectProjectDeps(projectDir) {
+  const packagePath = path.join(projectDir, 'package.json');
+  if (!pathExists(packagePath)) {
+    return {
+      packagePath,
+      hasPackageJson: false,
+      missing: Object.keys(REQUIRED_DEPS),
+      present: [],
+      pkg: null,
+    };
+  }
+
+  const pkg = readJson(packagePath, {});
+  const allDeps = {
+    ...(pkg.dependencies || {}),
+    ...(pkg.devDependencies || {}),
+  };
+  const missing = Object.keys(REQUIRED_DEPS).filter((name) => !allDeps[name]);
+  const present = Object.keys(REQUIRED_DEPS).filter((name) => Boolean(allDeps[name]));
+
+  return {
+    packagePath,
+    hasPackageJson: true,
+    missing,
+    present,
+    pkg,
+  };
+}
+
+export function ensurePackageJsonDeps(projectDir, inspection = inspectProjectDeps(projectDir)) {
+  let pkg = inspection.pkg;
+  let createdPackageJson = false;
+
+  if (!inspection.hasPackageJson) {
+    pkg = {
+      name: path.basename(projectDir).toLowerCase().replace(/[^a-z0-9-_]+/g, '-') || 'phaser-casual-game',
+      private: true,
+      type: 'module',
+      dependencies: {},
+    };
+    createdPackageJson = true;
+  }
+
+  pkg.dependencies = pkg.dependencies || {};
+  const added = [];
+  for (const [name, version] of Object.entries(REQUIRED_DEPS)) {
+    const already =
+      Boolean(pkg.dependencies?.[name]) || Boolean(pkg.devDependencies?.[name]);
+    if (!already) {
+      pkg.dependencies[name] = version;
+      added.push(name);
+    }
+  }
+
+  writeJson(inspection.packagePath, pkg);
+
+  return {
+    createdPackageJson,
+    added,
+    packagePath: inspection.packagePath,
+  };
+}
+
+function quoteForCmd(value) {
+  const text = String(value);
+  if (/[\s&<>|^"()]/g.test(text)) {
+    return `"${text.replaceAll('"', '""')}"`;
+  }
+  return text;
+}
+
+export function npmInstallDeps(projectDir, packageNames = Object.keys(REQUIRED_DEPS)) {
+  // package.json already contains the versions from ensurePackageJsonDeps().
+  const args = ['install', ...packageNames, '--save'];
+  const commandSummary = `npm ${args.join(' ')}`;
+
+  let result;
+  if (process.platform === 'win32') {
+    const commandLine = ['npm', ...args].map(quoteForCmd).join(' ');
+    result = spawnSync(process.env.ComSpec || 'cmd.exe', ['/d', '/s', '/c', commandLine], {
+      cwd: projectDir,
+      stdio: 'inherit',
+      env: process.env,
+      windowsHide: true,
+    });
+  } else {
+    result = spawnSync('npm', args, {
+      cwd: projectDir,
+      stdio: 'inherit',
+      env: process.env,
+    });
+  }
+
+  if (result.error) {
+    throw new Error(`Failed to run npm install: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    throw new Error(`npm install exited with code ${result.status}`);
+  }
+
+  return {
+    installed: packageNames,
+    command: commandSummary,
+  };
+}
+
+export async function resolveAndInstallDeps(projectDir, { confirm, createIfMissing = true } = {}) {
+  const inspection = inspectProjectDeps(projectDir);
+
+  if (inspection.missing.length === 0) {
+    return {
+      status: 'already-present',
+      missing: [],
+      present: inspection.present,
+      installed: false,
+    };
+  }
+
+  if (!confirm) {
+    return {
+      status: 'skipped',
+      missing: inspection.missing,
+      present: inspection.present,
+      installed: false,
+      hasPackageJson: inspection.hasPackageJson,
+    };
+  }
+
+  if (!inspection.hasPackageJson && !createIfMissing) {
+    return {
+      status: 'skipped-no-package-json',
+      missing: inspection.missing,
+      present: [],
+      installed: false,
+      hasPackageJson: false,
+    };
+  }
+
+  const ensured = ensurePackageJsonDeps(projectDir, inspection);
+  const npm = npmInstallDeps(projectDir, ensured.added.length > 0 ? ensured.added : inspection.missing);
+
+  return {
+    status: 'installed',
+    missing: inspection.missing,
+    present: inspection.present,
+    installed: true,
+    createdPackageJson: ensured.createdPackageJson,
+    added: ensured.added,
+    npm,
+  };
+}

package/installer/fs-utils.js

@@ -0,0 +1,58 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+export function pathExists(targetPath) {
+  try {
+    fs.accessSync(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function readJson(filePath, fallback = null) {
+  if (!pathExists(filePath)) {
+    return fallback;
+  }
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+export function writeJson(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+
+export function copyDirectory(sourceDir, targetDir) {
+  ensureDir(targetDir);
+  fs.cpSync(sourceDir, targetDir, {
+    recursive: true,
+    force: true,
+    filter: (source) => {
+      const base = path.basename(source);
+      if (base === 'node_modules' || base === 'dist' || base === 'test-results' || base === 'playwright-report') {
+        return false;
+      }
+      return true;
+    },
+  });
+}
+
+export function copyFile(sourcePath, targetPath) {
+  ensureDir(path.dirname(targetPath));
+  fs.copyFileSync(sourcePath, targetPath);
+}
+
+export function listSkillNames(skillsRoot) {
+  if (!pathExists(skillsRoot)) {
+    return [];
+  }
+  return fs
+    .readdirSync(skillsRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .sort();
+}