vibeman 0.0.9 → 0.0.11

package/dist/prisma/schema.prisma

@@ -4,7 +4,6 @@ generator client {
 
 datasource db {
   provider = "sqlite"
-  url      = env("DATABASE_URL")
 }
 
 model Setting {

package/dist/prisma.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'prisma/config';
+
+export default defineConfig({
+  schema: 'prisma/schema.prisma',
+  datasource: {
+    url: process.env.DATABASE_URL ?? 'file:./prisma/dev.db',
+  },
+});

package/dist/scripts/init-test-repo.mjs

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import { basename, resolve } from 'node:path';
+
+import {
+  PRIMARY_TEST_TASK_ID,
+  PRIMARY_TEST_WORKFLOW_ID,
+  TEST_FIXTURE_TASKS,
+  TEST_FIXTURE_WORKFLOWS,
+  buildTaskMarkdown,
+  getRepoRoot,
+  readTaskTemplate,
+  taskFilename,
+  taskRelativePath,
+} from './lib/test-fixtures.mjs';
+
+function parseArgs(argv) {
+  const args = {
+    path: '',
+    force: false,
+    skipDbSeed: false,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+
+    if (arg === '--path') {
+      args.path = argv[i + 1] ?? '';
+      i += 1;
+      continue;
+    }
+
+    if (arg === '--force') {
+      args.force = true;
+      continue;
+    }
+
+    if (arg === '--skip-db-seed') {
+      args.skipDbSeed = true;
+      continue;
+    }
+
+    if (!arg.startsWith('-') && !args.path) {
+      args.path = arg;
+    }
+  }
+
+  return args;
+}
+
+function runCommand(cmd, cmdArgs, options = {}) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn(cmd, cmdArgs, {
+      stdio: options.stdio ?? 'inherit',
+      cwd: options.cwd,
+      env: options.env,
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    if (child.stdout) {
+      child.stdout.on('data', (chunk) => {
+        stdout += chunk.toString();
+      });
+    }
+    if (child.stderr) {
+      child.stderr.on('data', (chunk) => {
+        stderr += chunk.toString();
+      });
+    }
+
+    child.on('error', (error) => {
+      rejectPromise(error);
+    });
+
+    child.on('exit', (code) => {
+      if (code === 0) {
+        resolvePromise({ stdout, stderr });
+        return;
+      }
+      rejectPromise(
+        new Error(
+          `Command failed (${code ?? 'null'}): ${cmd} ${cmdArgs.join(' ')}\n${stderr || stdout}`,
+        ),
+      );
+    });
+  });
+}
+
+async function ensureDirectoryIsEmpty(targetRoot, force) {
+  await mkdir(targetRoot, { recursive: true });
+  const entries = await readdir(targetRoot, { withFileTypes: true });
+  const allowedNames = new Set(['.git', '.DS_Store']);
+  const blocked = entries.filter((entry) => !allowedNames.has(entry.name));
+
+  if (blocked.length > 0 && !force) {
+    const names = blocked.map((entry) => entry.name).join(', ');
+    throw new Error(
+      `Target directory is not empty: ${targetRoot}\nFound: ${names}\nUse --force to continue.`,
+    );
+  }
+}
+
+async function writeTaskTemplate(targetRoot) {
+  const templatePath = resolve(targetRoot, '.vibeman/templates/task.md');
+  await mkdir(resolve(targetRoot, '.vibeman/templates'), { recursive: true });
+  await writeFile(templatePath, readTaskTemplate(), 'utf8');
+}
+
+async function writeFixtureTaskFiles(targetRoot) {
+  const tasksDir = resolve(targetRoot, '.vibeman/tasks');
+  await mkdir(tasksDir, { recursive: true });
+
+  const nowIso = new Date().toISOString();
+
+  for (const taskDef of TEST_FIXTURE_TASKS) {
+    const taskPath = resolve(tasksDir, taskFilename(taskDef.id));
+    await writeFile(taskPath, buildTaskMarkdown(taskDef, nowIso), 'utf8');
+  }
+}
+
+async function upsertGitignore(targetRoot) {
+  const gitignorePath = resolve(targetRoot, '.gitignore');
+  const requiredLines = ['.vibeman/vibeman.db', '.vibeman/uploads'];
+
+  let existing = '';
+  if (existsSync(gitignorePath)) {
+    existing = await readFile(gitignorePath, 'utf8');
+  }
+
+  const lines = existing
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+  const current = new Set(lines);
+  let changed = false;
+
+  for (const line of requiredLines) {
+    if (!current.has(line)) {
+      lines.push(line);
+      changed = true;
+    }
+  }
+
+  if (!existsSync(gitignorePath) || changed) {
+    const next = `${lines.join('\n')}\n`;
+    await writeFile(gitignorePath, next, 'utf8');
+  }
+}
+
+async function ensureGitRepo(targetRoot) {
+  const hasGitDir = existsSync(resolve(targetRoot, '.git'));
+  if (!hasGitDir) {
+    await runCommand('git', ['init'], { cwd: targetRoot });
+  }
+
+  await runCommand('git', ['add', '.'], { cwd: targetRoot });
+
+  let hasHead = true;
+  try {
+    await runCommand('git', ['rev-parse', '--verify', 'HEAD'], {
+      cwd: targetRoot,
+      stdio: 'pipe',
+    });
+  } catch {
+    hasHead = false;
+  }
+
+  if (hasHead) {
+    return;
+  }
+
+  try {
+    await runCommand('git', ['config', 'user.email'], { cwd: targetRoot, stdio: 'pipe' });
+  } catch {
+    await runCommand('git', ['config', 'user.email', 'vibeman-fixture@example.com'], {
+      cwd: targetRoot,
+    });
+  }
+
+  try {
+    await runCommand('git', ['config', 'user.name'], { cwd: targetRoot, stdio: 'pipe' });
+  } catch {
+    await runCommand('git', ['config', 'user.name', 'Vibeman Fixture'], { cwd: targetRoot });
+  }
+
+  await runCommand('git', ['commit', '-m', 'chore: initialize vibeman test fixtures'], {
+    cwd: targetRoot,
+  });
+}
+
+async function seedFixtures(targetRoot) {
+  const repoRoot = getRepoRoot();
+  const scriptPath = resolve(repoRoot, 'scripts/seed-test-fixtures.mjs');
+
+  await runCommand('node', [scriptPath, '--root', targetRoot], {
+    cwd: repoRoot,
+  });
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const targetRoot = resolve(process.cwd(), args.path || '.');
+
+  await ensureDirectoryIsEmpty(targetRoot, args.force);
+  await writeTaskTemplate(targetRoot);
+  await writeFixtureTaskFiles(targetRoot);
+  await upsertGitignore(targetRoot);
+  await ensureGitRepo(targetRoot);
+
+  if (!args.skipDbSeed) {
+    await seedFixtures(targetRoot);
+  }
+
+  console.log('[fixture:init] done');
+  console.log(`  repo: ${targetRoot}`);
+  console.log(`  tasks: ${TEST_FIXTURE_TASKS.length}`);
+  console.log(`  workflows: ${TEST_FIXTURE_WORKFLOWS.length}`);
+  console.log(`  sample task: ${taskRelativePath(PRIMARY_TEST_TASK_ID)}`);
+  console.log(`  sample workflow: ${PRIMARY_TEST_WORKFLOW_ID}`);
+  console.log('');
+  console.log('Repository fixtures initialized. Start your app manually and run tests as needed.');
+  console.log(`Tip: vibeman start ${targetRoot}`);
+  console.log(`Open project root: ${basename(targetRoot)}`);
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`[fixture:init] failed: ${message}`);
+  process.exit(1);
+});