@perceo/perceo 0.1.1 → 0.2.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,390 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command4 } from "commander";
+
+// src/commands/init.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import fs2 from "fs/promises";
+import path2 from "path";
+
+// src/config.ts
+import fs from "fs/promises";
+import path from "path";
+var CONFIG_DIR = ".perceo";
+var BASE_CONFIG_FILE = "config.json";
+var LOCAL_CONFIG_FILE = "config.local.json";
+async function loadConfig(options = {}) {
+  const projectDir = path.resolve(options.projectDir ?? process.cwd());
+  const envPath = process.env.PERCEO_CONFIG_PATH;
+  const baseConfigPath = envPath ? resolveMaybeRelativePath(envPath, projectDir) : path.join(projectDir, CONFIG_DIR, BASE_CONFIG_FILE);
+  const baseConfig = await readJsonFile(baseConfigPath);
+  const isLocalEnv = (process.env.PERCEO_ENV || "").toLowerCase() === "local" || process.env.NODE_ENV === "development";
+  if (!isLocalEnv) {
+    return baseConfig;
+  }
+  const localConfigPath = path.join(projectDir, CONFIG_DIR, LOCAL_CONFIG_FILE);
+  const localExists = await fileExists(localConfigPath);
+  if (!localExists) {
+    return baseConfig;
+  }
+  const localConfig = await readJsonFile(localConfigPath);
+  return deepMerge(baseConfig, localConfig);
+}
+async function readJsonFile(filePath) {
+  const raw = await fs.readFile(filePath, "utf8");
+  return JSON.parse(raw);
+}
+async function fileExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveMaybeRelativePath(p, projectDir) {
+  if (path.isAbsolute(p)) return p;
+  return path.join(projectDir, p);
+}
+function deepMerge(target, source) {
+  if (Array.isArray(target) && Array.isArray(source)) {
+    return source;
+  }
+  if (isPlainObject(target) && isPlainObject(source)) {
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+      if (key in target) {
+        result[key] = deepMerge(target[key], source[key]);
+      } else {
+        result[key] = source[key];
+      }
+    }
+    return result;
+  }
+  return source;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+
+// src/commands/init.ts
+import { ObserverEngine } from "@perceo/observer-engine";
+var CONFIG_DIR2 = ".perceo";
+var CONFIG_FILE = "config.json";
+var initCommand = new Command("init").description("Initialize Perceo in your project").option("-d, --dir <directory>", "Project directory", process.cwd()).action(async (options) => {
+  const projectDir = path2.resolve(options.dir || process.cwd());
+  const spinner = ora(`Initializing Perceo in ${chalk.cyan(projectDir)}...`).start();
+  try {
+    const pkg = await readPackageJson(projectDir);
+    const projectName = pkg?.name || path2.basename(projectDir);
+    const framework = await detectFramework(projectDir, pkg);
+    const perceoDir = path2.join(projectDir, CONFIG_DIR2);
+    const perceoConfigPath = path2.join(perceoDir, CONFIG_FILE);
+    await fs2.mkdir(perceoDir, { recursive: true });
+    if (await fileExists2(perceoConfigPath)) {
+      spinner.stop();
+      console.log(chalk.yellow(`
+.perceo/${CONFIG_FILE} already exists. Skipping config generation.`));
+    } else {
+      const config = createDefaultConfig(projectName, framework);
+      await fs2.writeFile(perceoConfigPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+    }
+    const readmePath = path2.join(perceoDir, "README.md");
+    if (!await fileExists2(readmePath)) {
+      await fs2.writeFile(readmePath, createPerceoReadme(projectName), "utf8");
+    }
+    let bootstrapSummary = null;
+    try {
+      spinner.text = "Initializing flows and personas with Perceo Observer Engine...";
+      const config = await loadConfig({ projectDir });
+      const observerConfig = {
+        observer: config.observer,
+        flowGraph: config.flowGraph,
+        eventBus: config.eventBus
+      };
+      const engine = new ObserverEngine(observerConfig);
+      const result = await engine.bootstrapProject({
+        projectDir,
+        projectName,
+        framework
+      });
+      const warnings = result.warnings && result.warnings.length > 0 ? ` (${result.warnings.length} warning${result.warnings.length > 1 ? "s" : ""})` : "";
+      bootstrapSummary = `Initialized ${result.flowsInitialized} flow(s) and ${result.personasInitialized} persona(s)${warnings}.`;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.log(chalk.yellow(`
+\u26A0\uFE0F  Skipped automatic Observer bootstrap. You can configure managed services later. Details: ${message}`));
+    }
+    spinner.succeed("Perceo initialized successfully!");
+    console.log("\n" + chalk.bold("Project: ") + projectName);
+    console.log(chalk.bold("Detected framework: ") + framework);
+    console.log(chalk.bold("Config: ") + path2.relative(projectDir, perceoConfigPath));
+    if (bootstrapSummary) {
+      console.log(chalk.bold("Observer bootstrap: ") + bootstrapSummary);
+    }
+    console.log("\n" + chalk.bold("Next steps:"));
+    console.log("  1. Review and customize " + chalk.cyan(`.perceo/${CONFIG_FILE}`) + " for your project.");
+    console.log("  2. Set up local managed services (Neo4j, Supabase) as described in " + chalk.cyan(".perceo/README.md") + ".");
+    console.log("  3. Start the watcher with: " + chalk.cyan("perceo watch --dev --analyze"));
+    console.log("\n" + chalk.gray("For full architecture and managed services guides, see docs/cli_architecture.md."));
+  } catch (error) {
+    spinner.fail("Failed to initialize Perceo");
+    console.error(chalk.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+});
+async function readPackageJson(projectDir) {
+  const pkgPath = path2.join(projectDir, "package.json");
+  if (!await fileExists2(pkgPath)) return null;
+  try {
+    const raw = await fs2.readFile(pkgPath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function detectFramework(projectDir, pkg) {
+  const nextConfig = await fileExists2(path2.join(projectDir, "next.config.js"));
+  const nextConfigTs = await fileExists2(path2.join(projectDir, "next.config.ts"));
+  if (nextConfig || nextConfigTs) return "nextjs";
+  const remixConfig = await fileExists2(path2.join(projectDir, "remix.config.js"));
+  if (remixConfig) return "remix";
+  const deps = {
+    ...pkg?.dependencies || {},
+    ...pkg?.devDependencies || {}
+  };
+  if (deps["next"]) return "nextjs";
+  if (deps["react"] || deps["react-dom"]) return "react";
+  if (deps["@remix-run/react"]) return "remix";
+  if (deps["@angular/core"]) return "angular";
+  if (deps["vue"]) return "vue";
+  return "unknown";
+}
+async function fileExists2(p) {
+  try {
+    await fs2.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createDefaultConfig(projectName, framework) {
+  return {
+    version: "1.0",
+    project: {
+      name: projectName,
+      framework
+    },
+    observer: {
+      watch: {
+        paths: inferDefaultWatchPaths(framework),
+        ignore: ["node_modules/", ".next/", "dist/", "build/"],
+        debounceMs: 500,
+        autoTest: true
+      },
+      ci: {
+        strategy: "affected-flows",
+        parallelism: 5
+      },
+      analysis: {
+        useLLM: true,
+        llmThreshold: 0.7
+      }
+    },
+    analyzer: {
+      insights: {
+        enabled: true,
+        updateInterval: 3600,
+        minSeverity: "medium"
+      },
+      predictions: {
+        enabled: true,
+        model: "ml",
+        confidenceThreshold: 0.6
+      },
+      coverage: {
+        minCoverageScore: 0.7,
+        alertOnGaps: true
+      }
+    },
+    analytics: {
+      provider: "ga4",
+      credentials: "${ANALYTICS_CREDENTIALS}",
+      syncInterval: 300,
+      correlation: {
+        algorithm: "smith-waterman",
+        minSimilarity: 0.7
+      },
+      revenueTracking: {
+        enabled: true,
+        avgOrderValueSource: "analytics"
+      }
+    },
+    flowGraph: {
+      endpoint: "bolt://localhost:7687",
+      database: "Perceo"
+    },
+    eventBus: {
+      type: "in-memory",
+      redisUrl: "redis://localhost:6379"
+    },
+    notifications: {
+      slack: {
+        enabled: false,
+        webhook: ""
+      },
+      email: {
+        enabled: false,
+        recipients: []
+      }
+    }
+  };
+}
+function inferDefaultWatchPaths(framework) {
+  switch (framework) {
+    case "nextjs":
+      return ["app/", "src/"];
+    case "react":
+      return ["src/"];
+    case "remix":
+      return ["app/"];
+    case "angular":
+      return ["src/"];
+    case "vue":
+      return ["src/"];
+    default:
+      return ["src/"];
+  }
+}
+function createPerceoReadme(projectName) {
+  return `# Perceo configuration for ${projectName}
+
+This folder was generated by \`perceo init\` and contains configuration for the Perceo CLI.
+
+## Files
+
+- \`.perceo/config.json\` \u2014 main configuration file for the Perceo CLI.
+
+## What this config does
+
+- Tells the Perceo backend which project and framework you are using.
+- Configures how the Observer, Analyzer, and Analytics features should behave for this project.
+- Stores connection settings that the Perceo backend and packages use to talk to managed services.
+
+The actual connection logic and authentication to Perceo-managed services (including any databases, event buses, or analytics backends) is handled by Perceo\u2019s backend packages and platform \u2014 not by this CLI config.
+
+In most cases you should only need to:
+
+1. Review \`.perceo/config.json\` and adjust paths (for example, \`src/\` vs \`app/\`).
+2. Commit \`.perceo/config.json\` to your repository (if you want it shared with your team).
+3. Run:
+
+\`\`\`bash
+perceo watch --dev --analyze
+\`\`\`
+
+to start Perceo in your local development workflow.
+`;
+}
+
+// src/commands/watch.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+import ora2 from "ora";
+import { ObserverEngine as ObserverEngine2 } from "@perceo/observer-engine";
+var watchCommand = new Command2("watch").description("Watch for code changes and run tests").option("--dev", "Run against local development server").option("--port <port>", "Development server port", "3000").action(async (options) => {
+  const spinner = ora2("Starting Perceo observer...").start();
+  try {
+    const config = await loadConfig();
+    const observerConfig = {
+      observer: config.observer,
+      flowGraph: config.flowGraph,
+      eventBus: config.eventBus
+    };
+    const engine = new ObserverEngine2(observerConfig);
+    spinner.succeed("Observer started");
+    console.log(chalk2.blue("\n\u{1F440} Watching for changes..."));
+    console.log(chalk2.gray("Press Ctrl+C to stop\n"));
+    const envLabel = (process.env.PERCEO_ENV || "").toLowerCase() === "local" ? chalk2.yellow("local (using .perceo/config.local.json overrides when present)") : chalk2.green("default");
+    console.log(chalk2.bold("Environment: "), envLabel);
+    if (config?.flowGraph?.endpoint) {
+      console.log(chalk2.bold("Flow graph endpoint: "), config.flowGraph.endpoint);
+    }
+    if (config?.eventBus?.type) {
+      console.log(chalk2.bold("Event bus: "), config.eventBus.type);
+    }
+    if (options.dev) {
+      console.log(chalk2.green(`\u2713 Connected to localhost:${options.port}`));
+    }
+    process.stdin.resume();
+  } catch (error) {
+    spinner.fail("Failed to start observer");
+    console.error(chalk2.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+});
+
+// src/commands/ci.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+import ora3 from "ora";
+import { ObserverEngine as ObserverEngine3 } from "@perceo/observer-engine";
+var ci = new Command3("ci").description("CI / PR analysis and testing");
+ci.command("analyze").description("Analyze changes between two Git refs and report affected flows").requiredOption("--base <sha>", "Base Git ref / SHA").requiredOption("--head <sha>", "Head Git ref / SHA").option("--project-dir <dir>", "Project directory (defaults to process.cwd())").option("--json", "Print machine-readable JSON output", false).action(async (options) => {
+  const projectRoot = options.projectDir ? options.projectDir : process.cwd();
+  const spinner = ora3("Analyzing changes with Perceo Observer Engine...").start();
+  try {
+    const rawConfig = await loadConfig({ projectDir: projectRoot });
+    const observerConfig = {
+      observer: rawConfig.observer,
+      flowGraph: rawConfig.flowGraph,
+      eventBus: rawConfig.eventBus
+    };
+    const engine = new ObserverEngine3(observerConfig);
+    const report = await engine.analyzeChanges({
+      baseSha: options.base,
+      headSha: options.head,
+      projectRoot
+    });
+    spinner.succeed("Analysis complete");
+    if (options.json) {
+      process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+      return;
+    }
+    console.log();
+    console.log(chalk3.bold("Change: ") + `${report.baseSha}...${report.headSha}`);
+    console.log(chalk3.bold("Flows affected: ") + report.flows.length);
+    if (report.flows.length > 0) {
+      console.log();
+      for (const flow of report.flows) {
+        const risk = flow.riskScore.toFixed(2);
+        const confidence = (flow.confidence * 100).toFixed(0) + "%";
+        const priority = flow.priority ? ` [${flow.priority}]` : "";
+        console.log(`- ${chalk3.cyan(flow.name)}${priority} (risk=${risk}, confidence=${confidence})`);
+      }
+    }
+    if (report.changes.length > 0) {
+      console.log();
+      console.log(chalk3.bold("Files changed:"));
+      for (const file of report.changes) {
+        console.log(`- [${file.status}] ${file.path}`);
+      }
+    }
+  } catch (error) {
+    spinner.fail("Analysis failed");
+    console.error(chalk3.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+});
+var ciCommand = ci;
+
+// src/index.ts
+var program = new Command4();
+program.name("perceo").description("Intelligent regression testing through multi-agent simulation").version("0.1.0");
+program.addCommand(initCommand);
+program.addCommand(watchCommand);
+program.addCommand(ciCommand);
+program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@perceo/perceo",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Intelligent regression testing through multi-agent simulation",
   "keywords": [
     "testing",
@@ -33,14 +33,15 @@
   "dependencies": {
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
-    "ora": "^8.0.1"
+    "ora": "^8.0.1",
+    "@perceo/observer-engine": "1.0.0"
   },
   "devDependencies": {
     "@changesets/cli": "^2.29.8",
     "@types/node": "^20.11.0",
     "tsup": "^8.0.1",
     "typescript": "^5.3.3",
-    "@repo/typescript-config": "0.0.0"
+    "@repo/typescript-config": "0.2.0"
   },
   "engines": {
     "node": ">=18"