@oalacea/demon 1.0.0

package/lib/config.js

@@ -0,0 +1,237 @@
+/**
+ * Demon - Configuration Utilities
+ *
+ * Handles project configuration and settings.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Get project root directory
+ */
+function getProjectRoot() {
+  let currentDir = process.cwd();
+
+  while (currentDir !== path.parse(currentDir).root) {
+    const pkgPath = path.join(currentDir, 'package.json');
+
+    if (fs.existsSync(pkgPath)) {
+      return currentDir;
+    }
+
+    currentDir = path.dirname(currentDir);
+  }
+
+  return process.cwd();
+}
+
+/**
+ * Read package.json
+ */
+function readPackageJson(projectDir = getProjectRoot()) {
+  const pkgPath = path.join(projectDir, 'package.json');
+
+  if (!fs.existsSync(pkgPath)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get all dependencies
+ */
+function getDependencies(projectDir = getProjectRoot()) {
+  const pkg = readPackageJson(projectDir);
+
+  if (!pkg) {
+    return {};
+  }
+
+  return {
+    ...(pkg.dependencies || {}),
+    ...(pkg.devDependencies || {}),
+  };
+}
+
+/**
+ * Check if a dependency exists
+ */
+function hasDependency(depName, projectDir = getProjectRoot()) {
+  const deps = getDependencies(projectDir);
+  return depName in deps;
+}
+
+/**
+ * Get dependency version
+ */
+function getDependencyVersion(depName, projectDir = getProjectRoot()) {
+  const deps = getDependencies(projectDir);
+  return deps[depName] || null;
+}
+
+/**
+ * Check if project uses TypeScript
+ */
+function isTypeScriptProject(projectDir = getProjectRoot()) {
+  return (
+    hasDependency('typescript', projectDir) ||
+    fs.existsSync(path.join(projectDir, 'tsconfig.json'))
+  );
+}
+
+/**
+ * Get test runner
+ */
+function getTestRunner(projectDir = getProjectRoot()) {
+  const deps = getDependencies(projectDir);
+
+  if (deps.vitest) return 'vitest';
+  if (deps.jest) return 'jest';
+  if (deps.mocha) return 'mocha';
+  if (deps.jasmine) return 'jasmine';
+
+  // Check config files
+  const vitestConfig = path.join(projectDir, 'vitest.config.ts');
+  const jestConfig = path.join(projectDir, 'jest.config.js');
+
+  if (fs.existsSync(vitestConfig)) return 'vitest';
+  if (fs.existsSync(jestConfig)) return 'jest';
+
+  return 'vitest'; // Default
+}
+
+/**
+ * Get framework
+ */
+function getFramework(projectDir = getProjectRoot()) {
+  const deps = getDependencies(projectDir);
+
+  if (deps.next) return 'Next.js';
+  if (deps['@remix-run/node']) return 'Remix';
+  if (deps['@sveltejs/kit']) return 'SvelteKit';
+  if (deps.nuxt) return 'Nuxt';
+  if (deps.astro) return 'Astro';
+  if (deps.gatsby) return 'Gatsby';
+  if (deps.vite) return 'Vite';
+  if (deps.express) return 'Express';
+  if (deps.nest) return 'NestJS';
+
+  return 'Unknown';
+}
+
+/**
+ * Get database config
+ */
+function getDatabaseConfig(projectDir = getProjectRoot()) {
+  const deps = getDependencies(projectDir);
+
+  if (deps['@prisma/client']) {
+    return {
+      type: 'Prisma',
+      schemaPath: path.join(projectDir, 'prisma', 'schema.prisma'),
+    };
+  }
+
+  if (deps['drizzle-orm']) {
+    return {
+      type: 'Drizzle',
+    };
+  }
+
+  if (deps.typeorm) {
+    return {
+      type: 'TypeORM',
+    };
+  }
+
+  if (deps.mongoose) {
+    return {
+      type: 'Mongoose',
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Get environment variable
+ */
+function getEnvVar(key, defaultValue = null) {
+  return process.env[key] || defaultValue;
+}
+
+/**
+ * Get Demon config from package.json
+ */
+function getDemonConfig(projectDir = getProjectRoot()) {
+  const pkg = readPackageJson(projectDir);
+
+  if (!pkg || !pkg.demon) {
+    return {};
+  }
+
+  return pkg.demon;
+}
+
+/**
+ * Get source directory
+ */
+function getSourceDir(projectDir = getProjectRoot()) {
+  const srcDir = path.join(projectDir, 'src');
+  const appDir = path.join(projectDir, 'app');
+
+  if (fs.existsSync(appDir)) {
+    return 'app';
+  }
+
+  if (fs.existsSync(srcDir)) {
+    return 'src';
+  }
+
+  return '.';
+}
+
+/**
+ * Get test directory
+ */
+function getTestDir(projectDir = getProjectRoot()) {
+  const testsDir = path.join(projectDir, 'tests');
+  const testDir = path.join(projectDir, 'test');
+  const srcTestsDir = path.join(getSourceDir(projectDir), 'tests');
+
+  if (fs.existsSync(testsDir)) {
+    return 'tests';
+  }
+
+  if (fs.existsSync(testDir)) {
+    return 'test';
+  }
+
+  if (fs.existsSync(srcTestsDir)) {
+    return path.join(getSourceDir(projectDir), 'tests');
+  }
+
+  return 'tests';
+}
+
+module.exports = {
+  getProjectRoot,
+  readPackageJson,
+  getDependencies,
+  hasDependency,
+  getDependencyVersion,
+  isTypeScriptProject,
+  getTestRunner,
+  getFramework,
+  getDatabaseConfig,
+  getEnvVar,
+  getDemonConfig,
+  getSourceDir,
+  getTestDir,
+};

package/lib/docker.js

@@ -0,0 +1,207 @@
+/**
+ * Demon - Docker Management
+ *
+ * Handles Docker container operations for the Demon toolkit.
+ */
+
+const { execSync } = require('child_process');
+
+const CONFIG = {
+  imageName: 'demon-tools',
+  containerName: 'demon-tools',
+  dockerfile: path.join(__dirname, '..', 'bin', 'Dockerfile'),
+};
+
+/**
+ * Check if Docker is running
+ */
+function isDockerRunning() {
+  try {
+    execSync('docker info', { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if image exists
+ */
+function imageExists() {
+  try {
+    const output = execSync(`docker images -q ${CONFIG.imageName}`, { stdio: 'pipe' });
+    return output.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Build the Docker image
+ */
+function buildImage(options = {}) {
+  const cmd = `docker build -t ${CONFIG.imageName} -f "${CONFIG.dockerfile}" "${path.dirname(CONFIG.dockerfile)}"`;
+
+  return execSync(cmd, {
+    stdio: options.silent ? 'pipe' : 'inherit',
+    timeout: options.timeout || 600000, // 10 minutes
+  });
+}
+
+/**
+ * Check if container is running
+ */
+function isContainerRunning() {
+  try {
+    const output = execSync(
+      `docker ps --filter "name=^${CONFIG.containerName}$" --format "{{.Names}}"`,
+      { stdio: 'pipe' }
+    );
+    return output.trim() === CONFIG.containerName;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if container exists
+ */
+function containerExists() {
+  try {
+    const output = execSync(
+      `docker ps -a --filter "name=^${CONFIG.containerName}$" --format "{{.Names}}"`,
+      { stdio: 'pipe' }
+    );
+    return output.trim() === CONFIG.containerName;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Start container
+ */
+function startContainer() {
+  const cmd = `docker start ${CONFIG.containerName}`;
+  return execSync(cmd, { stdio: 'pipe' });
+}
+
+/**
+ * Create container
+ */
+function createContainer(options = {}) {
+  const isLinux = process.platform === 'linux';
+  const networkFlag = isLinux ? '--network=host' : '';
+  const cmd = `docker run -d --name ${CONFIG.containerName} ${networkFlag} ${CONFIG.imageName}`;
+
+  return execSync(cmd, { stdio: 'pipe' });
+}
+
+/**
+ * Stop container
+ */
+function stopContainer() {
+  try {
+    return execSync(`docker stop ${CONFIG.containerName}`, { stdio: 'pipe' });
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Remove container
+ */
+function removeContainer() {
+  try {
+    return execSync(`docker rm -f ${CONFIG.containerName}`, { stdio: 'pipe' });
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Execute command in container
+ */
+function execInContainer(command, options = {}) {
+  const cmd = `docker exec ${CONFIG.containerName} ${command}`;
+
+  try {
+    return {
+      success: true,
+      output: execSync(cmd, {
+        encoding: 'utf-8',
+        stdio: options.silent ? 'pipe' : 'inherit',
+        timeout: options.timeout || 60000,
+      }),
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message,
+      output: error.stdout || '',
+    };
+  }
+}
+
+/**
+ * Get container logs
+ */
+function getLogs(options = {}) {
+  const tail = options.tail || 100;
+  const cmd = `docker logs --tail ${tail} ${CONFIG.containerName}`;
+
+  try {
+    return execSync(cmd, { encoding: 'utf-8', stdio: 'pipe' });
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Setup container (build, start, or create as needed)
+ */
+async function setupContainer(options = {}) {
+  // Check Docker
+  if (!isDockerRunning()) {
+    throw new Error('Docker is not running');
+  }
+
+  // Build image if needed
+  if (!imageExists()) {
+    if (options.onBuildStart) {
+      options.onBuildStart();
+    }
+    buildImage({ silent: options.silent });
+    if (options.onBuildComplete) {
+      options.onBuildComplete();
+    }
+  }
+
+  // Start or create container
+  if (isContainerRunning()) {
+    return { status: 'running' };
+  }
+
+  if (containerExists()) {
+    startContainer();
+    return { status: 'started' };
+  }
+
+  createContainer();
+  return { status: 'created' };
+}
+
+module.exports = {
+  isDockerRunning,
+  imageExists,
+  buildImage,
+  isContainerRunning,
+  containerExists,
+  startContainer,
+  createContainer,
+  stopContainer,
+  removeContainer,
+  execInContainer,
+  getLogs,
+  setupContainer,
+};