@a-company/paradigm 5.11.0 → 5.21.0

package/dist/conductor-CQVGTEQN.js

@@ -1,161 +0,0 @@
-#!/usr/bin/env node
-import {
-  log
-} from "./chunk-4NCFWYGG.js";
-import "./chunk-PDX44BCA.js";
-
-// src/commands/conductor.ts
-import { execSync, spawn } from "child_process";
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import { fileURLToPath } from "url";
-import chalk from "chalk";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path.dirname(__filename);
-var INSTALLED_BINARY = path.join(os.homedir(), ".paradigm", "conductor", "bin", "conductor");
-async function conductorCommand(options) {
-  const cmdLog = log.command("conductor");
-  if (options.install) {
-    await installConductor(options, cmdLog);
-    return;
-  }
-  const binaryPath = resolveBinary(options, cmdLog);
-  if (!binaryPath) {
-    return;
-  }
-  if (options.build) {
-    const conductorDir = findConductorDir();
-    if (conductorDir) {
-      buildFromSource(conductorDir, options, cmdLog);
-      const devBinary = path.join(conductorDir, ".build", "release", "conductor");
-      launchBinary(devBinary, cmdLog);
-      return;
-    } else {
-      cmdLog.error("--build requires the Paradigm monorepo");
-      console.log(chalk.gray("  Run from inside the a-paradigm repo, or use --install to update the global binary."));
-      process.exit(1);
-    }
-  }
-  launchBinary(binaryPath, cmdLog);
-}
-function resolveBinary(options, cmdLog) {
-  if (fs.existsSync(INSTALLED_BINARY)) {
-    return INSTALLED_BINARY;
-  }
-  const conductorDir = findConductorDir();
-  if (conductorDir) {
-    const devBinary = path.join(conductorDir, ".build", "release", "conductor");
-    if (fs.existsSync(devBinary)) {
-      return devBinary;
-    }
-    cmdLog.info("Dev binary not found, building\u2026");
-    buildFromSource(conductorDir, options, cmdLog);
-    if (fs.existsSync(devBinary)) {
-      return devBinary;
-    }
-  }
-  cmdLog.error("Conductor binary not found");
-  console.log("");
-  console.log(chalk.white("  To install Conductor:"));
-  console.log(chalk.cyan("    cd <paradigm-repo> && paradigm conductor --install"));
-  console.log("");
-  console.log(chalk.gray("  This builds the native binary and installs it to ~/.paradigm/conductor/bin/"));
-  console.log(chalk.gray("  After that, `paradigm conductor` works from any directory."));
-  console.log("");
-  process.exit(1);
-  return null;
-}
-async function installConductor(options, cmdLog) {
-  const conductorDir = findConductorDir();
-  if (!conductorDir) {
-    cmdLog.error("Cannot install \u2014 not in the Paradigm monorepo");
-    console.log(chalk.gray("  Run this command from inside the a-paradigm repository."));
-    process.exit(1);
-  }
-  const devBinary = path.join(conductorDir, ".build", "release", "conductor");
-  if (!fs.existsSync(devBinary) || options.build) {
-    buildFromSource(conductorDir, options, cmdLog);
-  }
-  if (!fs.existsSync(devBinary)) {
-    cmdLog.error("Build did not produce a binary");
-    process.exit(1);
-  }
-  const installDir = path.dirname(INSTALLED_BINARY);
-  fs.mkdirSync(installDir, { recursive: true });
-  fs.copyFileSync(devBinary, INSTALLED_BINARY);
-  fs.chmodSync(INSTALLED_BINARY, 493);
-  const size = (fs.statSync(INSTALLED_BINARY).size / (1024 * 1024)).toFixed(1);
-  cmdLog.success(`Conductor installed (${size} MB)`);
-  console.log("");
-  console.log(chalk.green("  \u2713 ") + chalk.white("Installed to ") + chalk.cyan("~/.paradigm/conductor/bin/conductor"));
-  console.log(chalk.green("  \u2713 ") + chalk.white("Run ") + chalk.cyan("paradigm conductor") + chalk.white(" from any directory"));
-  console.log("");
-}
-function buildFromSource(conductorDir, options, cmdLog) {
-  cmdLog.info("Building Conductor\u2026");
-  try {
-    execSync("swift build -c release", {
-      cwd: conductorDir,
-      stdio: options.verbose ? "inherit" : "pipe"
-    });
-    cmdLog.success("Build complete");
-  } catch (error) {
-    cmdLog.error("Build failed");
-    const errMsg = error.message || "";
-    if (errMsg.includes("xcode-select")) {
-      console.log(chalk.gray("  Xcode Command Line Tools are required."));
-      console.log(chalk.gray("  Install with: xcode-select --install"));
-    } else {
-      console.log(chalk.gray(`  ${errMsg.slice(0, 200)}`));
-    }
-    process.exit(1);
-  }
-}
-function launchBinary(binaryPath, cmdLog) {
-  cmdLog.info("Launching Conductor\u2026");
-  const child = spawn(binaryPath, [], {
-    detached: true,
-    stdio: "ignore"
-  });
-  child.unref();
-  const isInstalled = binaryPath === INSTALLED_BINARY;
-  console.log(chalk.cyan("\n  Paradigm Conductor is running."));
-  if (isInstalled) {
-    console.log(chalk.gray("  Binary: ~/.paradigm/conductor/bin/conductor"));
-  }
-  console.log(chalk.gray("  Look for the waveform icon in your menu bar."));
-  console.log(chalk.gray("  Quit via the menu bar icon or Cmd+Q.\n"));
-}
-function findConductorDir() {
-  let dir = path.resolve(__dirname, "..");
-  for (let i = 0; i < 5; i++) {
-    const candidate = path.join(dir, "packages", "conductor");
-    if (fs.existsSync(path.join(candidate, "Package.swift"))) {
-      return candidate;
-    }
-    dir = path.dirname(dir);
-  }
-  const cwdCandidate = path.join(process.cwd(), "packages", "conductor");
-  if (fs.existsSync(path.join(cwdCandidate, "Package.swift"))) {
-    return cwdCandidate;
-  }
-  if (fs.existsSync(path.join(process.cwd(), "Package.swift"))) {
-    const basename2 = path.basename(process.cwd());
-    if (basename2 === "conductor") {
-      return process.cwd();
-    }
-  }
-  let cwdDir = process.cwd();
-  for (let i = 0; i < 5; i++) {
-    cwdDir = path.dirname(cwdDir);
-    const candidate = path.join(cwdDir, "packages", "conductor");
-    if (fs.existsSync(path.join(candidate, "Package.swift"))) {
-      return candidate;
-    }
-  }
-  return null;
-}
-export {
-  conductorCommand
-};

package/dist/config-schema-EA4XALGG.js

@@ -1,154 +0,0 @@
-#!/usr/bin/env node
-import "./chunk-PDX44BCA.js";
-
-// src/core/config-schema.ts
-import { z } from "zod";
-import * as yaml from "js-yaml";
-var disciplineEnum = z.enum([
-  "web",
-  "backend",
-  "fullstack",
-  "api",
-  "cli",
-  "ml",
-  "mobile",
-  "game",
-  "embedded",
-  "devops",
-  "data",
-  "library",
-  "monorepo",
-  "custom"
-]);
-var agentProviderEnum = z.enum([
-  "auto",
-  "claude",
-  "claude-code",
-  "cursor-cli",
-  "claude-cli",
-  "manual"
-]);
-var symbolDefinitionSchema = z.object({
-  name: z.string(),
-  description: z.string(),
-  examples: z.array(z.string()).optional()
-}).passthrough();
-var tagBankSchema = z.object({
-  file: z.string().optional(),
-  "core-tags": z.array(z.string()).optional(),
-  "allow-suggestions": z.boolean().optional()
-}).passthrough();
-var agentGuidelinesSchema = z.object({
-  overview: z.string().optional(),
-  "how-to-use": z.array(z.string()).optional(),
-  "update-rules": z.array(z.string()).optional()
-}).passthrough();
-var loggingSchema = z.object({
-  enforce: z.boolean().optional(),
-  "default-level": z.enum(["debug", "info", "warn", "error"]).optional(),
-  "symbol-mapping": z.record(z.string(), z.string()).optional()
-}).passthrough();
-var purposeRequiredEntry = z.object({
-  pattern: z.string(),
-  depth: z.number().optional()
-});
-var limitsSchema = z.object({
-  toolCacheTtlMs: z.number().optional()
-}).passthrough();
-var aiAgentSchema = z.object({
-  model: z.string().optional(),
-  "context-window": z.number().optional()
-}).passthrough();
-var contextSchema = z.object({
-  enabled: z.boolean().optional(),
-  "index-file": z.string().optional(),
-  "docs-path": z.string().optional()
-}).passthrough();
-var probeSchema = z.object({
-  enabled: z.boolean().optional(),
-  "auto-include": z.boolean().optional()
-}).passthrough();
-var paradigmConfigSchema = z.object({
-  version: z.string(),
-  project: z.string(),
-  discipline: disciplineEnum.optional(),
-  "agent-provider": agentProviderEnum.optional(),
-  "agent-guidelines": agentGuidelinesSchema.optional(),
-  "symbol-system": z.record(z.string(), symbolDefinitionSchema).optional(),
-  "tag-bank": tagBankSchema.optional(),
-  component_types: z.record(z.string(), z.string()).optional(),
-  logging: loggingSchema.optional(),
-  "purpose-required": z.array(purposeRequiredEntry).optional(),
-  conventions: z.array(z.string()).optional(),
-  workspace: z.string().optional(),
-  limits: limitsSchema.optional(),
-  "ai-agent": aiAgentSchema.optional(),
-  context: contextSchema.optional(),
-  probe: probeSchema.optional(),
-  states: z.record(z.string(), z.unknown()).optional(),
-  "custom-symbols": z.record(z.string(), symbolDefinitionSchema).optional()
-}).passthrough();
-var KNOWN_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
-  "version",
-  "project",
-  "discipline",
-  "agent-provider",
-  "agent-guidelines",
-  "symbol-system",
-  "tag-bank",
-  "component_types",
-  "logging",
-  "purpose-required",
-  "conventions",
-  "workspace",
-  "limits",
-  "ai-agent",
-  "context",
-  "probe",
-  "states",
-  "custom-symbols",
-  "docs",
-  "features"
-]);
-function validateConfig(content) {
-  const warnings = [];
-  const errors = [];
-  let parsed;
-  try {
-    parsed = yaml.load(content);
-  } catch (e) {
-    return {
-      valid: false,
-      warnings: [],
-      errors: [`YAML parse error: ${e.message}`]
-    };
-  }
-  if (!parsed || typeof parsed !== "object") {
-    return {
-      valid: false,
-      warnings: [],
-      errors: ["Config must be a YAML object"]
-    };
-  }
-  for (const key of Object.keys(parsed)) {
-    if (!KNOWN_TOP_LEVEL_KEYS.has(key)) {
-      warnings.push(`Unrecognized config key: "${key}"`);
-    }
-  }
-  const result = paradigmConfigSchema.safeParse(parsed);
-  if (!result.success) {
-    for (const issue of result.error.issues) {
-      const path = issue.path.join(".");
-      errors.push(`${path}: ${issue.message}`);
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    warnings,
-    errors
-  };
-}
-export {
-  paradigmConfigSchema,
-  validateConfig
-};

package/dist/constellation-A26CCGQS.js

@@ -1,225 +0,0 @@
-#!/usr/bin/env node
-import {
-  aggregateFromDirectory,
-  buildSymbolIndex,
-  getAllSymbols,
-  getSymbolCounts,
-  getSymbolsByType
-} from "./chunk-ZGUAAVMA.js";
-import "./chunk-EDOAWN7J.js";
-import "./chunk-IRKUEJVW.js";
-import {
-  log
-} from "./chunk-4NCFWYGG.js";
-import "./chunk-PDX44BCA.js";
-
-// src/commands/constellation.ts
-import * as fs from "fs";
-import * as path from "path";
-import chalk from "chalk";
-import ora from "ora";
-function categorizeReferences(refs) {
-  const categories = {
-    gates: [],
-    signals: [],
-    components: [],
-    flows: [],
-    aspects: []
-  };
-  for (const ref of refs) {
-    if (!ref || ref.length < 2) continue;
-    const prefix = ref[0];
-    switch (prefix) {
-      case "^":
-        categories.gates.push(ref);
-        break;
-      case "!":
-        categories.signals.push(ref);
-        break;
-      case "#":
-        categories.components.push(ref);
-        break;
-      case "$":
-        categories.flows.push(ref);
-        break;
-      case "~":
-        categories.aspects.push(ref);
-        break;
-    }
-  }
-  return categories;
-}
-function buildConstellation(index, projectName) {
-  const stars = {};
-  const orbits = {};
-  const counts = getSymbolCounts(index);
-  const allSymbols = getAllSymbols(index);
-  for (const entry of allSymbols) {
-    const categories = categorizeReferences(entry.references);
-    const star = {
-      type: entry.type,
-      path: entry.filePath,
-      references: entry.references,
-      referencedBy: entry.referencedBy
-    };
-    if (entry.description) star.description = entry.description;
-    if (entry.tags && entry.tags.length > 0) star.tags = entry.tags;
-    if (categories.gates.length > 0) star.gates = categories.gates;
-    if (categories.signals.length > 0) star.signals = categories.signals;
-    if (categories.components.length > 0) star.components = categories.components;
-    if (categories.flows.length > 0) star.flows = categories.flows;
-    if (categories.aspects.length > 0) star.aspects = categories.aspects;
-    stars[entry.symbol] = star;
-  }
-  const flowSymbols = getSymbolsByType(index, "flow");
-  for (const flow of flowSymbols) {
-    const data = flow.data;
-    const sequence = data?.sequence || data?.gates || flow.references;
-    orbits[flow.symbol] = {
-      description: flow.description,
-      sequence
-    };
-  }
-  return {
-    version: "1.0",
-    generated: (/* @__PURE__ */ new Date()).toISOString(),
-    project: projectName,
-    stats: {
-      components: counts.component,
-      flows: counts.flow,
-      gates: counts.gate,
-      signals: counts.signal,
-      aspects: counts.aspect,
-      total: Object.values(counts).reduce((a, b) => a + b, 0)
-    },
-    stars,
-    orbits
-  };
-}
-async function constellationCommand(targetPath, options = {}) {
-  const cwd = process.cwd();
-  const absolutePath = targetPath ? path.resolve(cwd, targetPath) : cwd;
-  const projectName = path.basename(absolutePath);
-  const format = options.format || "json";
-  if (!options.quiet) {
-    console.log(chalk.blue("\n\u2728 Building Constellation...\n"));
-  }
-  const spinner = ora("Aggregating symbols...").start();
-  const tracker = log.command("constellation").start("Building constellation", { project: projectName });
-  try {
-    const result = await aggregateFromDirectory(absolutePath);
-    const index = buildSymbolIndex(result);
-    log.operation("aggregate").debug("Symbols aggregated", { count: getAllSymbols(index).length });
-    spinner.text = "Building constellation...";
-    const constellation = buildConstellation(index, projectName);
-    const paradigmDir = path.join(absolutePath, ".paradigm");
-    if (!fs.existsSync(paradigmDir)) {
-      fs.mkdirSync(paradigmDir, { recursive: true });
-    }
-    const outputPath = options.output || path.join(paradigmDir, `constellation.${format}`);
-    let content;
-    if (format === "yaml") {
-      content = serializeToYaml(constellation);
-    } else {
-      content = JSON.stringify(constellation, null, 2);
-    }
-    fs.writeFileSync(outputPath, content, "utf8");
-    log.component("constellation-file").success("Constellation written", { path: outputPath, format });
-    spinner.succeed("Constellation built");
-    tracker.success("Constellation built", { path: outputPath, stars: Object.keys(constellation.stars).length });
-    if (!options.quiet) {
-      console.log(chalk.white("\nConstellation Stats"));
-      console.log(chalk.gray("\u2500".repeat(40)));
-      const stats = constellation.stats;
-      const statLines = [
-        { symbol: "#", name: "Components", count: stats.components, color: chalk.green },
-        { symbol: "$", name: "Flows", count: stats.flows, color: chalk.yellow },
-        { symbol: "^", name: "Gates", count: stats.gates, color: chalk.red },
-        { symbol: "!", name: "Signals", count: stats.signals, color: chalk.cyan },
-        { symbol: "~", name: "Aspects", count: stats.aspects, color: chalk.magenta }
-      ];
-      for (const { symbol, name, count, color } of statLines) {
-        if (count > 0) {
-          console.log(`  ${color(symbol)} ${name.padEnd(12)} ${chalk.cyan(count.toString())}`);
-        }
-      }
-      console.log(chalk.gray("\u2500".repeat(40)));
-      console.log(`  Total stars:    ${chalk.cyan(stats.total.toString())}`);
-      console.log(`  Total orbits:   ${chalk.cyan(Object.keys(constellation.orbits).length.toString())}`);
-      console.log(chalk.gray(`
-  Output: ${outputPath}
-`));
-      const sampleStar = Object.entries(constellation.stars).find(
-        ([, star]) => star.references.length > 0 || star.referencedBy.length > 0
-      );
-      if (sampleStar) {
-        console.log(chalk.white("Sample Star"));
-        console.log(chalk.gray("\u2500".repeat(40)));
-        console.log(chalk.cyan(`  ${sampleStar[0]}`));
-        const star = sampleStar[1];
-        if (star.gates?.length) console.log(chalk.gray(`    gates: ${star.gates.join(", ")}`));
-        if (star.components?.length) console.log(chalk.gray(`    components: ${star.components.join(", ")}`));
-        if (star.signals?.length) console.log(chalk.gray(`    signals: ${star.signals.join(", ")}`));
-        if (star.referencedBy.length) console.log(chalk.gray(`    referencedBy: ${star.referencedBy.join(", ")}`));
-        console.log("");
-      }
-    }
-    if (result.errors.length > 0 && !options.quiet) {
-      console.log(chalk.yellow("Warnings"));
-      console.log(chalk.gray("\u2500".repeat(40)));
-      for (const error of result.errors.slice(0, 5)) {
-        console.log(chalk.yellow(`  \u26A0 ${error.filePath}: ${error.message}`));
-      }
-      if (result.errors.length > 5) {
-        console.log(chalk.gray(`  ... and ${result.errors.length - 5} more`));
-      }
-      console.log("");
-    }
-    return constellation;
-  } catch (error) {
-    spinner.fail("Failed to build constellation");
-    tracker.error("Constellation build failed", { error: error.message });
-    console.log(chalk.red(`Error: ${error.message}
-`));
-    process.exit(1);
-  }
-}
-function serializeToYaml(obj, indent = 0) {
-  const spaces = "  ".repeat(indent);
-  if (obj === null || obj === void 0) {
-    return "null";
-  }
-  if (typeof obj === "string") {
-    if (obj.includes(":") || obj.includes("#") || obj.includes("\n") || obj.startsWith("@") || obj.startsWith("^")) {
-      return `"${obj.replace(/"/g, '\\"')}"`;
-    }
-    return obj;
-  }
-  if (typeof obj === "number" || typeof obj === "boolean") {
-    return String(obj);
-  }
-  if (Array.isArray(obj)) {
-    if (obj.length === 0) return "[]";
-    return obj.map((item) => `${spaces}- ${serializeToYaml(item, indent)}`).join("\n");
-  }
-  if (typeof obj === "object") {
-    const entries = Object.entries(obj);
-    if (entries.length === 0) return "{}";
-    return entries.map(([key, value]) => {
-      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-        return `${spaces}${key}:
-${serializeToYaml(value, indent + 1)}`;
-      }
-      if (Array.isArray(value)) {
-        if (value.length === 0) return `${spaces}${key}: []`;
-        return `${spaces}${key}:
-${serializeToYaml(value, indent + 1)}`;
-      }
-      return `${spaces}${key}: ${serializeToYaml(value, indent)}`;
-    }).join("\n");
-  }
-  return String(obj);
-}
-export {
-  constellationCommand
-};