@omiron33/omi-neuron-web 0.1.0

package/dist/cli/index.cjs

@@ -0,0 +1,571 @@
+#!/usr/bin/env node
+'use strict';
+
+var chunkFXKXMSLY_cjs = require('../chunk-FXKXMSLY.cjs');
+var chunkCOO66N7H_cjs = require('../chunk-COO66N7H.cjs');
+var chunkBSOSHBDR_cjs = require('../chunk-BSOSHBDR.cjs');
+var commander = require('commander');
+var path2 = require('path');
+var fs = require('fs/promises');
+var chalk = require('chalk');
+var url = require('url');
+var promises = require('readline/promises');
+var process$1 = require('process');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path2__default = /*#__PURE__*/_interopDefault(path2);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var chalk__default = /*#__PURE__*/_interopDefault(chalk);
+
+var logger = {
+  info: (message) => {
+    console.log(chalk__default.default.cyan(`[omi-neuron] ${message}`));
+  },
+  success: (message) => {
+    console.log(chalk__default.default.green(`[omi-neuron] ${message}`));
+  },
+  warn: (message) => {
+    console.warn(chalk__default.default.yellow(`[omi-neuron] ${message}`));
+  },
+  error: (message) => {
+    console.error(chalk__default.default.red(`[omi-neuron] ${message}`));
+  }
+};
+var renderTemplate = (template, values) => {
+  let output2 = template;
+  for (const [key, value] of Object.entries(values)) {
+    output2 = output2.replace(new RegExp(`{{${key}}}`, "g"), value);
+  }
+  return output2;
+};
+async function writeTemplateFile(filePath, template, values, force = false) {
+  const resolved = path2__default.default.resolve(filePath);
+  await fs__default.default.mkdir(path2__default.default.dirname(resolved), { recursive: true });
+  try {
+    await fs__default.default.access(resolved);
+    if (!force) {
+      throw new Error(`File already exists: ${resolved}`);
+    }
+  } catch {
+  }
+  const content = renderTemplate(template, values);
+  await fs__default.default.writeFile(resolved, content, "utf8");
+}
+
+// src/cli/commands/init.ts
+var CONFIG_TEMPLATE = `import { defineNeuronConfig, DEFAULT_ANALYSIS_SETTINGS, DEFAULT_VISUALIZATION_SETTINGS } from 'omi-neuron-web';
+
+export default defineNeuronConfig({
+  instance: {
+    name: '{{INSTANCE_NAME}}',
+    version: '0.1.0',
+    repoName: '{{REPO_NAME}}',
+  },
+  visualization: DEFAULT_VISUALIZATION_SETTINGS,
+  analysis: DEFAULT_ANALYSIS_SETTINGS,
+  nodeTypes: [],
+  domains: [],
+  relationshipTypes: [],
+  openai: {
+    apiKey: process.env.OPENAI_API_KEY ?? '',
+  },
+  database: {
+    mode: 'docker',
+    port: {{DB_PORT}},
+    user: 'neuron',
+    password: 'neuron_dev',
+    database: 'neuron_web',
+  },
+  api: {
+    basePath: '/api/neuron',
+    enableCors: false,
+  },
+  logging: {
+    level: 'info',
+    prettyPrint: true,
+  },
+});
+`;
+var ENV_TEMPLATE = `# omi-neuron-web environment variables
+OPENAI_API_KEY=
+DATABASE_URL=
+`;
+var DOCKER_TEMPLATE = `version: '3.8'
+
+services:
+  pg-{{REPO_NAME}}:
+    image: pgvector/pgvector:pg16
+    container_name: pg-{{REPO_NAME}}
+    restart: unless-stopped
+    environment:
+      POSTGRES_USER: neuron
+      POSTGRES_PASSWORD: neuron_dev
+      POSTGRES_DB: neuron_web
+    ports:
+      - "{{DB_PORT}}:5432"
+    volumes:
+      - {{REPO_NAME}}_neuron_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U neuron -d neuron_web"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+volumes:
+  {{REPO_NAME}}_neuron_data:
+    name: {{REPO_NAME}}_neuron_data
+`;
+var API_ROUTE_TEMPLATE = `import { createNeuronRoutes } from 'omi-neuron-web/api';
+import config from '../../../../neuron.config';
+
+const routes = createNeuronRoutes(config);
+
+export const GET = routes.health.GET;
+export const POST = routes.health.GET;
+`;
+var initCommand = new commander.Command("init").description("Initialize omi-neuron-web in your project").option("--name <name>", "Instance name (default: directory name)").option("--port <port>", "PostgreSQL port (default: 5433)", "5433").option("--skip-docker", "Don't generate Docker files").option("--skip-api", "Don't generate API route files").option("--skip-config", "Don't generate neuron.config.ts").option("--app-dir <path>", "Path to Next.js app directory", "./app").option("--force", "Overwrite existing files").action(async (options) => {
+  const repoName = path2__default.default.basename(process.cwd());
+  const instanceName = options.name ?? repoName;
+  const port = Number(options.port ?? 5433);
+  if (!options.skipConfig) {
+    await writeTemplateFile(
+      path2__default.default.join(process.cwd(), "neuron.config.ts"),
+      CONFIG_TEMPLATE,
+      {
+        INSTANCE_NAME: instanceName,
+        REPO_NAME: repoName,
+        DB_PORT: String(port)
+      },
+      options.force
+    );
+    logger.success("Created neuron.config.ts");
+  }
+  if (!options.skipDocker) {
+    await writeTemplateFile(
+      path2__default.default.join(process.cwd(), "docker-compose.neuron.yml"),
+      DOCKER_TEMPLATE,
+      {
+        REPO_NAME: repoName,
+        DB_PORT: String(port)
+      },
+      options.force
+    );
+    logger.success("Created docker-compose.neuron.yml");
+  }
+  await writeTemplateFile(
+    path2__default.default.join(process.cwd(), ".env.neuron.local"),
+    ENV_TEMPLATE,
+    {},
+    options.force
+  );
+  logger.success("Created .env.neuron.local");
+  if (!options.skipApi) {
+    const apiPath = path2__default.default.join(process.cwd(), options.appDir, "api", "neuron", "[...path]");
+    await fs__default.default.mkdir(apiPath, { recursive: true });
+    await fs__default.default.writeFile(path2__default.default.join(apiPath, "route.ts"), API_ROUTE_TEMPLATE, "utf8");
+    logger.success("Created Next.js API route stub");
+  }
+  logger.info("Initialization complete.");
+});
+async function loadNeuronConfig() {
+  const configPath = path2__default.default.resolve("neuron.config.ts");
+  try {
+    await fs__default.default.access(configPath);
+  } catch {
+    return null;
+  }
+  try {
+    const module = await import(url.pathToFileURL(configPath).toString());
+    return module.default ?? module;
+  } catch (error) {
+    throw new Error(
+      `Unable to load neuron.config.ts. Consider transpiling or using a JS config. ${String(error)}`
+    );
+  }
+}
+async function resolveCliConfig(overrides) {
+  const repoName = overrides?.repoName ?? path2__default.default.basename(process.cwd());
+  let config = null;
+  try {
+    config = await loadNeuronConfig();
+  } catch {
+    config = null;
+  }
+  return {
+    repoName,
+    port: overrides?.port ?? config?.database?.port ?? (process.env.DB_PORT ? Number(process.env.DB_PORT) : 5433),
+    containerName: overrides?.containerName ?? config?.database?.containerName,
+    databaseUrl: overrides?.databaseUrl ?? config?.database?.url ?? process.env.DATABASE_URL,
+    databaseUser: overrides?.databaseUser ?? config?.database?.user ?? process.env.DB_USER,
+    databasePassword: overrides?.databasePassword ?? config?.database?.password ?? process.env.DB_PASSWORD,
+    databaseName: overrides?.databaseName ?? config?.database?.database ?? process.env.DB_NAME
+  };
+}
+async function confirmPrompt(message) {
+  const rl = promises.createInterface({ input: process$1.stdin, output: process$1.stdout });
+  const answer = await rl.question(`${message} (y/N): `);
+  rl.close();
+  return answer.trim().toLowerCase() === "y";
+}
+
+// src/cli/utils/spinner.ts
+var Spinner = class {
+  constructor(message) {
+    this.message = message;
+  }
+  state = "stopped";
+  intervalId = null;
+  frames = ["-", "\\", "|", "/"];
+  frameIndex = 0;
+  start() {
+    if (this.state === "running") return;
+    this.state = "running";
+    this.intervalId = setInterval(() => {
+      const frame = this.frames[this.frameIndex % this.frames.length];
+      this.frameIndex += 1;
+      process.stdout.write(`\r${frame} ${this.message}`);
+    }, 120);
+  }
+  stop(success = true, finalMessage) {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+    }
+    this.state = "stopped";
+    const symbol = success ? "\u2713" : "\u2717";
+    process.stdout.write(`\r${symbol} ${finalMessage ?? this.message}
+`);
+  }
+};
+
+// src/cli/commands/db.ts
+var buildConnectionString = (config) => {
+  if (config.databaseUrl) return config.databaseUrl;
+  const user = config.databaseUser ?? "neuron";
+  const password = config.databasePassword ?? "neuron_dev";
+  const database = config.databaseName ?? "neuron_web";
+  return `postgresql://${user}:${password}@localhost:${config.port}/${database}`;
+};
+var dbCommand = new commander.Command("db").description("Database management commands").addCommand(
+  new commander.Command("up").description("Start PostgreSQL container").option("--port <port>", "Override port").option("--force-recreate", "Force recreate container").option("--wait", "Wait for readiness", true).action(async (options) => {
+    const config = await resolveCliConfig({
+      port: options.port ? Number(options.port) : void 0
+    });
+    const docker = new chunkFXKXMSLY_cjs.DockerManager({
+      repoName: config.repoName,
+      port: config.port,
+      containerName: config.containerName,
+      user: config.databaseUser,
+      password: config.databasePassword,
+      database: config.databaseName
+    });
+    const spinner = new Spinner("Starting PostgreSQL container");
+    spinner.start();
+    await docker.start({
+      forceRecreate: options.forceRecreate,
+      waitForReady: options.wait
+    });
+    spinner.stop(true, "Database ready");
+    const connectionString = await docker.getConnectionString();
+    logger.info(`Connection string: ${connectionString}`);
+  })
+).addCommand(
+  new commander.Command("down").description("Stop PostgreSQL container").option("--remove-volumes", "Remove volumes (destructive)").action(async (options) => {
+    const config = await resolveCliConfig();
+    const docker = new chunkFXKXMSLY_cjs.DockerManager({
+      repoName: config.repoName,
+      port: config.port,
+      containerName: config.containerName
+    });
+    await docker.stop({ removeVolumes: options.removeVolumes });
+    logger.success("Database container stopped");
+  })
+).addCommand(
+  new commander.Command("migrate").description("Run migrations").option("--status", "Show status only").option("--rollback <count>", "Rollback N migrations").option("--to <version>", "Migrate to specific version").option("--dry-run", "Show SQL without executing").action(async (options) => {
+    const config = await resolveCliConfig();
+    const db = new chunkCOO66N7H_cjs.Database({
+      connectionString: buildConnectionString(config)
+    });
+    const runner = new chunkBSOSHBDR_cjs.MigrationRunner(db);
+    if (options.status) {
+      const status = await runner.getStatus();
+      status.forEach((item) => {
+        logger.info(`${item.version} ${item.name} - ${item.status}`);
+      });
+      return;
+    }
+    if (options.dryRun) {
+      const sql = await runner.dryRun(options.rollback ? "down" : "up");
+      logger.info(sql.join("\n\n"));
+      return;
+    }
+    if (options.rollback) {
+      await runner.down({ count: Number(options.rollback) });
+      logger.success("Rollback complete");
+      return;
+    }
+    await runner.up({ to: options.to });
+    logger.success("Migrations complete");
+  })
+).addCommand(
+  new commander.Command("status").description("Show database status").option("--json", "Output JSON").option("--verbose", "Include stats").action(async (options) => {
+    const config = await resolveCliConfig();
+    const docker = new chunkFXKXMSLY_cjs.DockerManager({
+      repoName: config.repoName,
+      port: config.port,
+      containerName: config.containerName
+    });
+    const health = await docker.healthCheck();
+    if (options.json) {
+      console.log(JSON.stringify(health, null, 2));
+      return;
+    }
+    logger.info(`Container running: ${health.containerRunning}`);
+    logger.info(`Database ready: ${health.databaseReady}`);
+    if (options.verbose) {
+      const stats = await docker.getStats();
+      logger.info(`Stats: ${JSON.stringify(stats)}`);
+    }
+  })
+).addCommand(
+  new commander.Command("reset").description("Reset database schema").option("--confirm", "Skip confirmation prompt").action(async (options) => {
+    if (!options.confirm) {
+      const confirmed = await confirmPrompt("This will drop and reapply all migrations. Continue?");
+      if (!confirmed) return;
+    }
+    const config = await resolveCliConfig();
+    const db = new chunkCOO66N7H_cjs.Database({
+      connectionString: buildConnectionString(config)
+    });
+    const runner = new chunkBSOSHBDR_cjs.MigrationRunner(db);
+    await runner.reset();
+    logger.success("Database reset complete");
+  })
+).addCommand(
+  new commander.Command("seed").description("Seed database with sample data").option("--file <path>", "Custom seed file").option("--clear", "Clear before seeding").option("--count <n>", "Number of example nodes", "10").action(async (options) => {
+    const config = await resolveCliConfig();
+    const db = new chunkCOO66N7H_cjs.Database({
+      connectionString: buildConnectionString(config)
+    });
+    if (options.clear) {
+      await db.execute("DELETE FROM edges");
+      await db.execute("DELETE FROM nodes");
+    }
+    const count = Number(options.count ?? 10);
+    for (let i = 0; i < count; i += 1) {
+      await db.execute(
+        "INSERT INTO nodes (slug, label, node_type, domain, metadata) VALUES ($1, $2, $3, $4, $5)",
+        [`seed-${i + 1}`, `Seed Node ${i + 1}`, "concept", "general", {}]
+      );
+    }
+    logger.success("Seed data inserted");
+  })
+);
+var buildConnectionString2 = (config) => {
+  if (config.databaseUrl) return config.databaseUrl;
+  const user = config.databaseUser ?? "neuron";
+  const password = config.databasePassword ?? "neuron_dev";
+  const database = config.databaseName ?? "neuron_web";
+  return `postgresql://${user}:${password}@localhost:${config.port}/${database}`;
+};
+async function buildPipeline() {
+  const config = await resolveCliConfig();
+  const db = new chunkCOO66N7H_cjs.Database({ connectionString: buildConnectionString2(config) });
+  const events = new chunkCOO66N7H_cjs.EventBus();
+  const embeddings = new chunkCOO66N7H_cjs.EmbeddingsService(
+    {
+      openaiApiKey: process.env.OPENAI_API_KEY ?? "",
+      model: "text-embedding-3-small",
+      batchSize: 20,
+      rateLimit: 60,
+      cacheTTL: 86400,
+      maxRetries: 3
+    },
+    db
+  );
+  const clustering = new chunkCOO66N7H_cjs.ClusteringEngine(db, embeddings);
+  const relationships = new chunkCOO66N7H_cjs.RelationshipEngine(db, {
+    model: "gpt-4o-mini",
+    minConfidence: 0.7,
+    maxPerNode: 10,
+    similarityThreshold: 0.75,
+    includeExisting: false,
+    batchSize: 10,
+    rateLimit: 30
+  });
+  return new chunkCOO66N7H_cjs.AnalysisPipeline(db, embeddings, clustering, relationships, events);
+}
+var analyzeCommand = new commander.Command("analyze").description("Analysis commands").addCommand(
+  new commander.Command("embeddings").description("Generate embeddings").option("--node-ids <ids>", "Comma-separated node IDs").option("--force", "Regenerate existing").action(async (options) => {
+    const pipeline = await buildPipeline();
+    const nodeIds = options.nodeIds ? options.nodeIds.split(",") : void 0;
+    await pipeline.runEmbeddings({ nodeIds, forceRecompute: options.force });
+    logger.success("Embeddings complete");
+  })
+).addCommand(
+  new commander.Command("cluster").description("Run clustering").option("--count <n>", "Number of clusters").option("--algorithm <alg>", "kmeans, dbscan, hierarchical", "kmeans").action(async (options) => {
+    const pipeline = await buildPipeline();
+    await pipeline.runClustering({
+      clusterCount: options.count ? Number(options.count) : void 0,
+      clusteringAlgorithm: options.algorithm
+    });
+    logger.success("Clustering complete");
+  })
+).addCommand(
+  new commander.Command("relationships").description("Infer relationships").option("--threshold <n>", "Min confidence (0-1)", "0.7").option("--dry-run", "Show without saving").action(async (options) => {
+    const pipeline = await buildPipeline();
+    await pipeline.runRelationships({
+      relationshipThreshold: Number(options.threshold)
+    });
+    logger.success("Relationship inference complete");
+  })
+).addCommand(
+  new commander.Command("full").description("Run full analysis pipeline").option("--force", "Force recompute all").action(async (options) => {
+    const pipeline = await buildPipeline();
+    await pipeline.runFull({ forceRecompute: options.force });
+    logger.success("Analysis pipeline complete");
+  })
+);
+var buildConnectionString3 = (config) => {
+  if (config.databaseUrl) return config.databaseUrl;
+  const user = config.databaseUser ?? "neuron";
+  const password = config.databasePassword ?? "neuron_dev";
+  const database = config.databaseName ?? "neuron_web";
+  return `postgresql://${user}:${password}@localhost:${config.port}/${database}`;
+};
+var validateCommand = new commander.Command("validate").description("Validate configuration and setup").option("--fix", "Attempt to fix issues").option("--verbose", "Show detailed validation").action(async (options) => {
+  const config = await resolveCliConfig();
+  let hasError = false;
+  const configPath = path2__default.default.resolve("neuron.config.ts");
+  try {
+    await fs__default.default.access(configPath);
+    logger.success("neuron.config.ts exists");
+  } catch {
+    hasError = true;
+    logger.error("neuron.config.ts not found");
+  }
+  try {
+    const docker = new chunkFXKXMSLY_cjs.DockerManager({ repoName: config.repoName, port: config.port });
+    const health = await docker.healthCheck();
+    logger.info(`Docker container running: ${health.containerRunning}`);
+    logger.info(`Database ready: ${health.databaseReady}`);
+  } catch (error) {
+    hasError = true;
+    logger.error(`Docker check failed: ${String(error)}`);
+  }
+  try {
+    const db = new chunkCOO66N7H_cjs.Database({ connectionString: buildConnectionString3(config) });
+    await db.connect();
+    logger.success("Database connection ok");
+    const runner = new chunkBSOSHBDR_cjs.MigrationRunner(db);
+    const pending = await runner.getPending();
+    if (pending.length > 0) {
+      logger.warn(`Pending migrations: ${pending.map((m) => m.version).join(", ")}`);
+    } else {
+      logger.success("Migrations up to date");
+    }
+  } catch (error) {
+    hasError = true;
+    logger.error(`Database check failed: ${String(error)}`);
+  }
+  if (!process.env.OPENAI_API_KEY) {
+    logger.warn("OPENAI_API_KEY not set");
+    if (options.fix) {
+      logger.info("Set OPENAI_API_KEY in your environment to enable analysis");
+    }
+  }
+  if (hasError) {
+    process.exitCode = 1;
+  }
+});
+var CONFIG_FILE = path2__default.default.resolve("neuron.config.ts");
+var serializeConfig = (config) => `import { defineNeuronConfig } from 'omi-neuron-web';
+
+export default defineNeuronConfig(${JSON.stringify(
+  config,
+  null,
+  2
+)});
+`;
+var getNestedValue = (obj, key) => {
+  return key.split(".").reduce((acc, part) => {
+    if (acc && typeof acc === "object" && part in acc) {
+      return acc[part];
+    }
+    return void 0;
+  }, obj);
+};
+var setNestedValue = (obj, key, value) => {
+  const parts = key.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i += 1) {
+    const part = parts[i];
+    if (!current[part] || typeof current[part] !== "object") {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+};
+var configCommand = new commander.Command("config").description("Manage neuron.config.ts").addCommand(
+  new commander.Command("get").argument("<key>", "Dot path key").action(async (key) => {
+    const config = await loadNeuronConfig();
+    if (!config) {
+      logger.error("neuron.config.ts not found");
+      return;
+    }
+    const value = getNestedValue(config, key);
+    console.log(JSON.stringify(value, null, 2));
+  })
+).addCommand(
+  new commander.Command("set").argument("<key>", "Dot path key").argument("<value>", "Value (JSON)").action(async (key, value) => {
+    const config = await loadNeuronConfig();
+    if (!config) {
+      logger.error("neuron.config.ts not found");
+      return;
+    }
+    const parsed = JSON.parse(value);
+    const updated = { ...config };
+    setNestedValue(updated, key, parsed);
+    await fs__default.default.writeFile(CONFIG_FILE, serializeConfig(updated), "utf8");
+    logger.success(`Updated ${key}`);
+  })
+).addCommand(
+  new commander.Command("list").action(async () => {
+    const config = await loadNeuronConfig();
+    if (!config) {
+      logger.error("neuron.config.ts not found");
+      return;
+    }
+    console.log(JSON.stringify(config, null, 2));
+  })
+).addCommand(
+  new commander.Command("reset").option("--section <section>", "Section to reset").action(async (options) => {
+    const config = await loadNeuronConfig();
+    if (!config) {
+      logger.error("neuron.config.ts not found");
+      return;
+    }
+    const updated = { ...config };
+    if (options.section) {
+      delete updated[options.section];
+    } else {
+      for (const key of Object.keys(updated)) {
+        delete updated[key];
+      }
+    }
+    await fs__default.default.writeFile(CONFIG_FILE, serializeConfig(updated), "utf8");
+    logger.success("Config reset");
+  })
+);
+
+// src/cli/index.ts
+commander.program.name("omi-neuron").description("CLI for omi-neuron-web library").version("0.1.0");
+commander.program.addCommand(initCommand);
+commander.program.addCommand(dbCommand);
+commander.program.addCommand(analyzeCommand);
+commander.program.addCommand(validateCommand);
+commander.program.addCommand(configCommand);
+commander.program.parse();
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map