ai-dev-setup 1.0.0

package/src/core/detector.js

@@ -0,0 +1,164 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+async function readJsonIfExists(cwd, name) {
+  try {
+    const p = path.join(cwd, name);
+    const raw = await fs.readFile(p, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+async function fileExists(cwd, name) {
+  try {
+    await fs.access(path.join(cwd, name));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function globFrameworkConfig(cwd, prefix) {
+  try {
+    const entries = await fs.readdir(cwd, { withFileTypes: true });
+    return entries.some((e) => e.isFile() && e.name.startsWith(prefix));
+  } catch {
+    return false;
+  }
+}
+
+function pickScript(scripts, keys) {
+  if (!scripts || typeof scripts !== 'object') return null;
+  for (const k of keys) {
+    if (typeof scripts[k] === 'string' && scripts[k].trim()) return scripts[k].trim();
+  }
+  return null;
+}
+
+function depsFromPkg(pkg) {
+  const d = pkg?.dependencies ?? {};
+  const dev = pkg?.devDependencies ?? {};
+  return { ...dev, ...d };
+}
+
+/**
+ * Auto-detect project stack from the file system.
+ * @param {string} cwd
+ */
+export async function detectProject(cwd) {
+  const result = {
+    name: null,
+    language: null,
+    framework: null,
+    testCmd: null,
+    lintCmd: null,
+    buildCmd: null,
+    database: null,
+    detectedStack: [],
+  };
+
+  const pkg = await readJsonIfExists(cwd, 'package.json');
+  if (pkg) {
+    if (typeof pkg.name === 'string' && pkg.name.trim()) result.name = pkg.name.trim();
+    const scripts = pkg.scripts;
+    result.testCmd = pickScript(scripts, ['test', 'test:unit', 'test:ci']);
+    result.lintCmd = pickScript(scripts, ['lint', 'eslint', 'check:lint']);
+    result.buildCmd = pickScript(scripts, ['build', 'compile', 'build:prod']);
+
+    const deps = depsFromPkg(pkg);
+    if (deps.react) {
+      result.detectedStack.push('react');
+      if (!result.framework) result.framework = 'React';
+    }
+    if (deps.next) {
+      result.detectedStack.push('nextjs');
+      result.framework = 'Next.js';
+    }
+    if (deps['@nestjs/core']) {
+      result.detectedStack.push('nestjs');
+      result.framework = 'NestJS';
+    }
+    if (deps.prisma) {
+      const schemaPath = path.join(cwd, 'prisma', 'schema.prisma');
+      try {
+        const schema = await fs.readFile(schemaPath, 'utf8');
+        if (/provider\s*=\s*"postgresql"/i.test(schema)) result.database = 'PostgreSQL';
+        else if (/provider\s*=\s*"mysql"/i.test(schema)) result.database = 'MySQL';
+        else if (/provider\s*=\s*"sqlite"/i.test(schema)) result.database = 'SQLite';
+      } catch {
+        result.database = result.database ?? 'PostgreSQL';
+      }
+    }
+    if (deps.typeorm) {
+      result.database = result.database ?? 'SQL (TypeORM)';
+    }
+    if (deps.pg || deps['pg-promise']) {
+      result.database = result.database ?? 'PostgreSQL';
+    }
+    if (deps.mysql2) {
+      result.database = result.database ?? 'MySQL';
+    }
+  }
+
+  const hasTsConfig = await fileExists(cwd, 'tsconfig.json');
+  if (hasTsConfig) {
+    result.detectedStack.push('ts');
+    result.language = 'TypeScript';
+  }
+
+  if (pkg && !hasTsConfig && !result.language) {
+    result.language = 'JavaScript';
+  }
+
+  if (await globFrameworkConfig(cwd, 'next.config')) {
+    if (!result.detectedStack.includes('nextjs')) result.detectedStack.push('nextjs');
+    result.framework = 'Next.js';
+  }
+
+  if (await readJsonIfExists(cwd, 'nest-cli.json')) {
+    if (!result.detectedStack.includes('nestjs')) result.detectedStack.push('nestjs');
+    result.framework = 'NestJS';
+  }
+
+  if (pkg) {
+    const deps = depsFromPkg(pkg);
+    const isNext = result.detectedStack.includes('nextjs');
+    if ((deps.express || deps.fastify || deps.koa || deps.hapi) && !isNext) {
+      result.detectedStack.push('node');
+      if (!result.framework || result.framework === 'React') {
+        result.framework = 'Node.js API';
+      }
+    }
+  }
+
+  if (await fileExists(cwd, 'pyproject.toml') || (await fileExists(cwd, 'requirements.txt'))) {
+    result.detectedStack.push('python');
+    result.language = 'Python';
+    if (!result.testCmd) result.testCmd = 'pytest';
+    if (!result.lintCmd) result.lintCmd = 'ruff check .';
+    if (!result.buildCmd) result.buildCmd = 'python -m build';
+  }
+
+  if (await fileExists(cwd, 'go.mod')) {
+    result.detectedStack.push('go');
+    result.language = 'Go';
+    if (!result.testCmd) result.testCmd = 'go test ./...';
+    if (!result.lintCmd) result.lintCmd = 'golangci-lint run';
+    if (!result.buildCmd) result.buildCmd = 'go build ./...';
+  }
+
+  if (await fileExists(cwd, 'pubspec.yaml')) {
+    result.detectedStack.push('flutter');
+    result.language = 'Dart';
+    result.framework = 'Flutter';
+    if (!result.testCmd) result.testCmd = 'flutter test';
+    if (!result.lintCmd) result.lintCmd = 'dart analyze';
+    if (!result.buildCmd) result.buildCmd = 'flutter build apk';
+  }
+
+  result.detectedStack = [...new Set(result.detectedStack)];
+
+  return result;
+}

package/src/core/git-ref.js

@@ -0,0 +1,28 @@
+const MAX_LEN = 256;
+/** Branch/tag names: alphanumerics, separators common in semver and paths */
+const SAFE_REF = /^[a-zA-Z0-9._/-]+$/;
+
+/**
+ * Validate a git ref before passing to `git clone -b`.
+ * @param {unknown} ref
+ * @returns {string}
+ */
+export function assertSafeGitRef(ref) {
+  if (ref == null || ref === '') {
+    throw new Error('Git ref must be non-empty');
+  }
+  const s = String(ref).trim();
+  if (s.length > MAX_LEN) {
+    throw new Error(`Git ref exceeds maximum length (${MAX_LEN})`);
+  }
+  if (s.includes('..')) {
+    throw new Error('Invalid git ref');
+  }
+  if (s.startsWith('-')) {
+    throw new Error('Invalid git ref');
+  }
+  if (!SAFE_REF.test(s)) {
+    throw new Error('Invalid git ref: use only letters, digits, and . _ / -');
+  }
+  return s;
+}

package/src/core/gitignore-vendor.js

@@ -0,0 +1,126 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+/** @see ensureVendorDirGitignored — stable section for merges */
+export const GITIGNORE_VENDOR_BEGIN = '# --- ai-dev-setup: vendor (managed) ---';
+export const GITIGNORE_VENDOR_END = '# --- end ai-dev-setup vendor ---';
+const VENDOR_LINE = '/vendor/';
+
+const HEADER =
+  '# ai-dev-setup: ignore cloned Superpowers + Agency (remove this block if you commit vendor/)\n';
+
+/**
+ * True if the line is a gitignore rule that ignores a root `vendor/` directory
+ * (or any path segment `vendor`, which is stronger).
+ * @param {string} line
+ */
+export function lineIgnoresRootVendor(line) {
+  const t = line.trim();
+  if (!t || t.startsWith('#')) return false;
+  const core = t.startsWith('!') ? t.slice(1).trim() : t;
+  // Root-only style: vendor, vendor/, /vendor, /vendor/, **/vendor, **/vendor/
+  if (/^(?:\*\*\/)?\/?vendor\/?$/.test(core)) return true;
+  return false;
+}
+
+/**
+ * @param {string} content
+ */
+export function fileAlreadyIgnoresVendorDir(content) {
+  const lines = content.split(/\r?\n/);
+  return lines.some((line) => lineIgnoresRootVendor(line));
+}
+
+function managedBlockPresent(content) {
+  return content.includes(GITIGNORE_VENDOR_BEGIN) && content.includes(GITIGNORE_VENDOR_END);
+}
+
+function blockInnerHasVendorLine(inner) {
+  return inner.split(/\r?\n/).some((l) => l.trim() === VENDOR_LINE);
+}
+
+function buildManagedBlock() {
+  return `${GITIGNORE_VENDOR_BEGIN}\n${VENDOR_LINE}\n${GITIGNORE_VENDOR_END}\n`;
+}
+
+/**
+ * @param {string} content normalized with \n
+ */
+function repairManagedBlock(content) {
+  const start = content.indexOf(GITIGNORE_VENDOR_BEGIN);
+  const end = content.indexOf(GITIGNORE_VENDOR_END, start);
+  if (start === -1 || end === -1) return null;
+  const afterBegin = start + GITIGNORE_VENDOR_BEGIN.length;
+  const inner = content.slice(afterBegin, end);
+  if (blockInnerHasVendorLine(inner)) return null;
+  return content.slice(0, afterBegin) + `\n${VENDOR_LINE}` + content.slice(afterBegin);
+}
+
+/**
+ * Ensure `.gitignore` ignores repo-root `vendor/` without clobbering user rules.
+ *
+ * @param {string} cwd
+ * @param {{ onWarn?: (msg: string) => void }} [opts]
+ * @returns {Promise<{ action: 'created' | 'appended_block' | 'repaired_block' | 'noop_already_ignored' | 'noop_managed_ok' | 'error', error?: string }>}
+ */
+export async function ensureVendorDirGitignored(cwd, opts = {}) {
+  const { onWarn } = opts;
+  const target = path.join(cwd, '.gitignore');
+
+  let raw = '';
+  try {
+    raw = await fs.readFile(target, 'utf8');
+  } catch (e) {
+    if (e && typeof e === 'object' && 'code' in e && e.code === 'ENOENT') {
+      raw = '';
+    } else {
+      const msg = e instanceof Error ? e.message : String(e);
+      onWarn?.(`.gitignore: could not read (${msg})`);
+      return { action: 'error', error: msg };
+    }
+  }
+
+  const content = raw.replace(/\r\n/g, '\n');
+
+  if (managedBlockPresent(content)) {
+    const repaired = repairManagedBlock(content);
+    if (repaired != null) {
+      try {
+        await fs.writeFile(target, ensureTrailingNewline(repaired), 'utf8');
+        return { action: 'repaired_block' };
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        onWarn?.(`.gitignore: could not write (${msg})`);
+        return { action: 'error', error: msg };
+      }
+    }
+    return { action: 'noop_managed_ok' };
+  }
+
+  if (fileAlreadyIgnoresVendorDir(content)) {
+    return { action: 'noop_already_ignored' };
+  }
+
+  const block = buildManagedBlock();
+  let next;
+  if (content.length === 0) {
+    next = HEADER + block;
+  } else {
+    const sep = content.endsWith('\n') ? '\n' : '\n\n';
+    next = content + sep + block;
+  }
+
+  try {
+    await fs.writeFile(target, ensureTrailingNewline(next), 'utf8');
+    return { action: content.length === 0 ? 'created' : 'appended_block' };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    onWarn?.(`.gitignore: could not write (${msg})`);
+    return { action: 'error', error: msg };
+  }
+}
+
+/** @param {string} s */
+function ensureTrailingNewline(s) {
+  return s.endsWith('\n') ? s : `${s}\n`;
+}

package/src/core/renderer.js

@@ -0,0 +1,97 @@
+import { readFile } from 'node:fs/promises';
+
+/**
+ * @param {string} key
+ * @param {Record<string, unknown>} config
+ */
+function evalConditional(key, config) {
+  const stacks = Array.isArray(config.stacks) ? config.stacks : [];
+  const lang = config.language;
+  switch (key) {
+    case 'TYPESCRIPT':
+      return lang === 'TypeScript';
+    case 'PYTHON':
+      return lang === 'Python';
+    case 'GO':
+      return lang === 'Go';
+    case 'JAVASCRIPT':
+      return lang === 'JavaScript';
+    case 'DART':
+      return lang === 'Dart';
+    case 'FLUTTER':
+      return stacks.includes('flutter');
+    case 'REACT':
+      return stacks.includes('react');
+    case 'NEXTJS':
+      return stacks.includes('nextjs');
+    case 'NESTJS':
+      return stacks.includes('nestjs');
+    case 'NODE':
+      return stacks.includes('node');
+    default:
+      return false;
+  }
+}
+
+/**
+ * Process {{#IF_KEY}}...{{/IF_KEY}} blocks.
+ * @param {string} template
+ * @param {Record<string, unknown>} config
+ */
+function processConditionals(template, config) {
+  const re = /\{\{#IF_([A-Z0-9_]+)\}\}([\s\S]*?)\{\{\/IF_\1\}\}/g;
+  return template.replace(re, (_, key, inner) => {
+    return evalConditional(key, config) ? inner : '';
+  });
+}
+
+const PLACEHOLDER_KEYS = [
+  'PROJECT_NAME',
+  'LANGUAGE',
+  'FRAMEWORK',
+  'TEST_CMD',
+  'LINT_CMD',
+  'BUILD_CMD',
+  'DATABASE',
+];
+
+/**
+ * @param {Record<string, unknown>} config
+ */
+function placeholderValue(key, config) {
+  const map = {
+    PROJECT_NAME: config.projectName,
+    LANGUAGE: config.language,
+    FRAMEWORK: config.framework,
+    TEST_CMD: config.testCmd,
+    LINT_CMD: config.lintCmd,
+    BUILD_CMD: config.buildCmd,
+    DATABASE: config.database,
+  };
+  const v = map[key];
+  return v == null ? '' : String(v);
+}
+
+/**
+ * Replaces {{PLACEHOLDER}} tokens; unknown tokens stay unchanged.
+ * @param {string} template
+ * @param {Record<string, unknown>} config
+ */
+export function render(template, config) {
+  let out = processConditionals(template, config);
+  for (const key of PLACEHOLDER_KEYS) {
+    const token = `{{${key}}}`;
+    const val = placeholderValue(key, config);
+    out = out.split(token).join(val);
+  }
+  return out;
+}
+
+/**
+ * @param {string} templatePath
+ * @param {Record<string, unknown>} config
+ */
+export async function renderFile(templatePath, config) {
+  const raw = await readFile(templatePath, 'utf8');
+  return render(raw, config);
+}