@a-company/paradigm 5.11.0 → 5.21.0

package/dist/server-XUOIO7E6.js

@@ -1,338 +0,0 @@
-#!/usr/bin/env node
-import "./chunk-PDX44BCA.js";
-
-// ../university/dist/chunk-CXHK3FVZ.js
-import express from "express";
-import * as path3 from "path";
-import * as fs3 from "fs";
-import { fileURLToPath } from "url";
-import chalk from "chalk";
-import { Router } from "express";
-import * as fs from "fs";
-import * as path from "path";
-import { Router as Router2 } from "express";
-import * as fs2 from "fs";
-import * as path2 from "path";
-function createCoursesRouter(contentDir) {
-  const router = Router();
-  router.get("/", (_req, res) => {
-    const coursesDir = path.join(contentDir, "courses");
-    if (!fs.existsSync(coursesDir)) {
-      return res.json({ courses: [] });
-    }
-    const files = fs.readdirSync(coursesDir).filter((f) => f.endsWith(".json"));
-    const courses = files.map((f) => {
-      const data = JSON.parse(fs.readFileSync(path.join(coursesDir, f), "utf-8"));
-      return {
-        id: data.id,
-        title: data.title,
-        description: data.description,
-        lessonCount: data.lessons?.length || 0,
-        lessons: (data.lessons || []).map((l) => ({
-          id: l.id,
-          title: l.title
-        }))
-      };
-    });
-    courses.sort((a, b) => a.id.localeCompare(b.id));
-    return res.json({ courses });
-  });
-  router.get("/:id", (req, res) => {
-    const courseFile = path.join(contentDir, "courses", `${req.params.id}.json`);
-    if (!fs.existsSync(courseFile)) {
-      return res.status(404).json({ error: `Course '${req.params.id}' not found` });
-    }
-    const data = JSON.parse(fs.readFileSync(courseFile, "utf-8"));
-    return res.json(data);
-  });
-  router.get("/:id/lessons/:lessonId", (req, res) => {
-    const courseFile = path.join(contentDir, "courses", `${req.params.id}.json`);
-    if (!fs.existsSync(courseFile)) {
-      return res.status(404).json({ error: `Course '${req.params.id}' not found` });
-    }
-    const data = JSON.parse(fs.readFileSync(courseFile, "utf-8"));
-    const lesson = (data.lessons || []).find((l) => l.id === req.params.lessonId);
-    if (!lesson) {
-      return res.status(404).json({ error: `Lesson '${req.params.lessonId}' not found` });
-    }
-    return res.json(lesson);
-  });
-  return router;
-}
-function pickVariant(variants) {
-  return variants[Math.floor(Math.random() * variants.length)];
-}
-function fisherYatesShuffle(arr) {
-  for (let i = arr.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [arr[i], arr[j]] = [arr[j], arr[i]];
-  }
-  return arr;
-}
-function resolveV3(data) {
-  const passages = {};
-  const blocks = [];
-  for (const item of data.items) {
-    if (item.type === "standalone" || item.type === "variant-group") {
-      const v = pickVariant(item.variants);
-      blocks.push([{
-        id: v.id,
-        course: item.course,
-        scenario: v.scenario,
-        question: v.question,
-        choices: v.choices,
-        correct: v.correct,
-        explanation: v.explanation
-      }]);
-    } else {
-      passages[item.slot] = item.passage;
-      const group = item.questions.map((pq) => {
-        const v = pickVariant(pq.variants);
-        return {
-          id: v.id,
-          course: item.course,
-          scenario: v.scenario,
-          question: v.question,
-          choices: v.choices,
-          correct: v.correct,
-          explanation: v.explanation,
-          passageId: item.slot
-        };
-      });
-      blocks.push(group);
-    }
-  }
-  fisherYatesShuffle(blocks);
-  return { questions: blocks.flat(), passages };
-}
-function countV3Questions(data) {
-  let count = 0;
-  for (const item of data.items) {
-    if (item.type === "standalone" || item.type === "variant-group") {
-      count += 1;
-    } else {
-      count += item.questions.length;
-    }
-  }
-  return count;
-}
-function createPlsatRouter(contentDir, projectDir) {
-  const router = Router2();
-  router.get("/", (_req, res) => {
-    const plsatDir = path2.join(contentDir, "plsat");
-    if (!fs2.existsSync(plsatDir)) {
-      return res.json({ versions: [] });
-    }
-    const files = fs2.readdirSync(plsatDir).filter((f) => f.endsWith(".json"));
-    const versions = files.map((f) => {
-      const data = JSON.parse(fs2.readFileSync(path2.join(plsatDir, f), "utf-8"));
-      const questionCount = data.items ? countV3Questions(data) : data.questions?.length || 0;
-      return {
-        version: data.version,
-        frameworkVersion: data.frameworkVersion,
-        questionCount,
-        timeLimit: data.timeLimit,
-        passThreshold: data.passThreshold
-      };
-    });
-    versions.sort((a, b) => b.version.localeCompare(a.version));
-    return res.json({ versions });
-  });
-  router.get("/:version", (req, res) => {
-    try {
-      const examFile = path2.join(contentDir, "plsat", `v${req.params.version}.json`);
-      if (!fs2.existsSync(examFile)) {
-        return res.status(404).json({ error: `PLSAT version '${req.params.version}' not found` });
-      }
-      const data = JSON.parse(fs2.readFileSync(examFile, "utf-8"));
-      if (data.items) {
-        const { questions, passages } = resolveV3(data);
-        return res.json({
-          version: data.version,
-          frameworkVersion: data.frameworkVersion,
-          timeLimit: data.timeLimit,
-          passThreshold: data.passThreshold,
-          title: data.title,
-          description: data.description,
-          questions,
-          ...Object.keys(passages).length > 0 ? { passages } : {}
-        });
-      }
-      const shuffled = [...data.questions].sort(() => Math.random() - 0.5);
-      return res.json({
-        ...data,
-        questions: shuffled
-      });
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : "Internal error";
-      return res.status(500).json({ error: `Failed to load PLSAT exam: ${msg}` });
-    }
-  });
-  router.post("/diploma", (req, res) => {
-    if (!projectDir) {
-      return res.status(400).json({ error: "No project directory configured" });
-    }
-    const diplomaDir = path2.join(projectDir, ".paradigm", "university", "diplomas");
-    if (!fs2.existsSync(diplomaDir)) {
-      return res.json({ saved: false, reason: "university directory not found" });
-    }
-    try {
-      const { student, version, score, total, percentage, passed } = req.body;
-      if (!student || !version || score == null || total == null) {
-        return res.status(400).json({ error: "Missing required fields: student, version, score, total" });
-      }
-      const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      const sanitizedStudent = String(student).toLowerCase().replace(/[^a-z0-9-]/g, "-").slice(0, 20);
-      const id = `D-${today}-${sanitizedStudent}-plsat-v${version}`;
-      const diploma = {
-        id,
-        type: "plsat",
-        student: sanitizedStudent,
-        earnedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        source: `plsat:v${version}`,
-        score,
-        total,
-        percentage: percentage ?? (total > 0 ? Math.round(score / total * 1e4) / 100 : 0),
-        passed: passed ?? false,
-        details: { plsatVersion: version }
-      };
-      const filePath = path2.join(diplomaDir, `${id}.yaml`);
-      const yamlLines = Object.entries(diploma).map(([k, v]) => {
-        if (typeof v === "object" && v !== null) {
-          const nested = Object.entries(v).map(([nk, nv]) => `  ${nk}: ${JSON.stringify(nv)}`).join("\n");
-          return `${k}:
-${nested}`;
-        }
-        return `${k}: ${JSON.stringify(v)}`;
-      });
-      fs2.writeFileSync(filePath, yamlLines.join("\n") + "\n", "utf8");
-      return res.json({ saved: true, diplomaId: id });
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : "Internal error";
-      return res.status(500).json({ error: `Failed to save diploma: ${msg}` });
-    }
-  });
-  return router;
-}
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path3.dirname(__filename);
-function findPackageRoot(startDir) {
-  let dir = startDir;
-  while (dir !== path3.dirname(dir)) {
-    if (fs3.existsSync(path3.join(dir, "package.json"))) {
-      const pkg = JSON.parse(fs3.readFileSync(path3.join(dir, "package.json"), "utf-8"));
-      if (pkg.name === "@a-company/university") return dir;
-    }
-    dir = path3.dirname(dir);
-  }
-  return startDir;
-}
-var log = {
-  component(name) {
-    const symbol = chalk.magenta(`#${name}`);
-    return {
-      info: (msg, data) => {
-        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
-        console.log(`${chalk.blue("\u2139")} ${symbol} ${msg}${dataStr}`);
-      },
-      success: (msg, data) => {
-        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
-        console.log(`${chalk.green("\u2714")} ${symbol} ${msg}${dataStr}`);
-      },
-      warn: (msg, data) => {
-        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
-        console.log(`${chalk.yellow("\u26A0")} ${symbol} ${msg}${dataStr}`);
-      },
-      error: (msg, data) => {
-        const dataStr = data ? chalk.gray(` ${Object.entries(data).map(([k, v]) => `${k}=${v}`).join(" ")}`) : "";
-        console.error(`${chalk.red("\u2716")} ${symbol} ${msg}${dataStr}`);
-      }
-    };
-  }
-};
-function resolveAssetPaths(options) {
-  if (options?.contentDir && options?.uiDistPath) {
-    return { contentDir: options.contentDir, uiDistPath: options.uiDistPath };
-  }
-  const bundledContent = path3.join(__dirname, "university-content");
-  const bundledUi = path3.join(__dirname, "university-ui");
-  if (fs3.existsSync(bundledContent) && fs3.existsSync(bundledUi)) {
-    return {
-      contentDir: options?.contentDir || bundledContent,
-      uiDistPath: options?.uiDistPath || bundledUi
-    };
-  }
-  const packageRoot = findPackageRoot(__dirname);
-  return {
-    contentDir: options?.contentDir || path3.join(packageRoot, "src", "content"),
-    uiDistPath: options?.uiDistPath || path3.join(packageRoot, "ui", "dist")
-  };
-}
-function createApp(options) {
-  const app = express();
-  app.use(express.json());
-  app.use((_req, res, next) => {
-    res.header("Access-Control-Allow-Origin", "*");
-    res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
-    res.header("Access-Control-Allow-Headers", "Content-Type");
-    next();
-  });
-  const { contentDir, uiDistPath } = resolveAssetPaths(options);
-  app.use("/api/courses", createCoursesRouter(contentDir));
-  app.use("/api/plsat", createPlsatRouter(contentDir, options?.projectDir));
-  app.get("/api/reference", (_req, res) => {
-    const refPath = path3.join(contentDir, "reference.json");
-    if (fs3.existsSync(refPath)) {
-      const data = JSON.parse(fs3.readFileSync(refPath, "utf-8"));
-      res.json(data);
-    } else {
-      res.status(404).json({ error: "Reference data not found" });
-    }
-  });
-  app.get("/api/health", (_req, res) => {
-    res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-  });
-  if (fs3.existsSync(uiDistPath)) {
-    app.use(express.static(uiDistPath));
-    app.get("{*path}", (req, res) => {
-      if (!req.path.startsWith("/api")) {
-        res.sendFile(path3.join(uiDistPath, "index.html"));
-      }
-    });
-  }
-  return app;
-}
-async function startServer(options) {
-  const app = createApp({
-    contentDir: options.contentDir,
-    uiDistPath: options.uiDistPath,
-    projectDir: options.projectDir
-  });
-  log.component("university-server").info("Starting server", { port: options.port });
-  return new Promise((resolve, reject) => {
-    const server = app.listen(options.port, () => {
-      log.component("university-server").success("Server running", { url: `http://localhost:${options.port}` });
-      if (options.open) {
-        import("open").then((openModule) => {
-          openModule.default(`http://localhost:${options.port}`);
-          log.component("university-server").info("Opened browser");
-        }).catch(() => {
-          log.component("university-server").warn("Could not open browser automatically");
-        });
-      }
-      resolve();
-    });
-    server.on("error", (err) => {
-      if (err.code === "EADDRINUSE") {
-        log.component("university-server").error("Port already in use", { port: options.port });
-      } else {
-        log.component("university-server").error("Server error", { error: err.message });
-      }
-      reject(err);
-    });
-  });
-}
-export {
-  createApp,
-  startServer
-};

package/dist/session-tracker-C4BMD5WG.js

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-import {
-  MODEL_PRICING,
-  getSessionTracker,
-  resetSessionTracker
-} from "./chunk-4L3UTYQX.js";
-import "./chunk-CL7JSK52.js";
-import "./chunk-7N7GSU6K.js";
-export {
-  MODEL_PRICING,
-  getSessionTracker,
-  resetSessionTracker
-};

package/dist/session-work-log-MZ47OAPB.js

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-import {
-  appendSessionWorkEntry,
-  clearSessionWorkLog,
-  getAgentEntries,
-  getAgentVerdicts,
-  getContributingAgents,
-  init_session_work_log,
-  readSessionWorkLog
-} from "./chunk-CL7JSK52.js";
-import "./chunk-7N7GSU6K.js";
-init_session_work_log();
-export {
-  appendSessionWorkEntry,
-  clearSessionWorkLog,
-  getAgentEntries,
-  getAgentVerdicts,
-  getContributingAgents,
-  readSessionWorkLog
-};

package/dist/setup-EDS27WUR.js

@@ -1,25 +0,0 @@
-#!/usr/bin/env node
-import {
-  detectAllClients,
-  generateMCPConfig,
-  getProjectName,
-  getServersFromConfig,
-  mcpListCommand,
-  mcpRemoveCommand,
-  mcpSetupCommand,
-  mcpStatusCommand,
-  writeConfig
-} from "./chunk-GZDFVP2N.js";
-import "./chunk-4NCFWYGG.js";
-import "./chunk-PDX44BCA.js";
-export {
-  detectAllClients,
-  generateMCPConfig,
-  getProjectName,
-  getServersFromConfig,
-  mcpListCommand,
-  mcpRemoveCommand,
-  mcpSetupCommand,
-  mcpStatusCommand,
-  writeConfig
-};

package/dist/setup-KO5AFC4K.js

@@ -1,296 +0,0 @@
-#!/usr/bin/env node
-import {
-  cursorrrulesExists,
-  writeCursorrules
-} from "./chunk-LHLIAYQ3.js";
-import "./chunk-36TKPM5Z.js";
-import {
-  getDefaultPremiseContent
-} from "./chunk-ZGUAAVMA.js";
-import {
-  getDefaultPurposeContent
-} from "./chunk-EDOAWN7J.js";
-import "./chunk-IRKUEJVW.js";
-import {
-  DEFAULT_CONVENTIONS,
-  DEFAULT_SYMBOL_SYSTEM,
-  serializeParadigmConfig
-} from "./chunk-YO6DVTL7.js";
-import "./chunk-PDX44BCA.js";
-
-// src/commands/setup.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as readline from "readline";
-import chalk from "chalk";
-function createPrompt() {
-  return readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-}
-async function ask(rl, question) {
-  return new Promise((resolve2) => {
-    rl.question(question, (answer) => {
-      resolve2(answer.trim());
-    });
-  });
-}
-async function askSelect(rl, message, choices) {
-  console.log(`
-${chalk.cyan(message)}`);
-  choices.forEach((choice, i) => {
-    console.log(chalk.gray(`  ${i + 1}) `) + choice.name);
-  });
-  const answer = await ask(rl, chalk.white(`Enter number (1-${choices.length}): `));
-  const index = parseInt(answer, 10) - 1;
-  if (index >= 0 && index < choices.length) {
-    return choices[index].value;
-  }
-  return choices[0].value;
-}
-async function askMultiSelect(rl, message, choices) {
-  console.log(`
-${chalk.cyan(message)}`);
-  choices.forEach((choice, i) => {
-    console.log(chalk.gray(`  ${i + 1}) `) + choice.name);
-  });
-  const answer = await ask(rl, chalk.white(`Enter numbers separated by commas (e.g., 1,2,3): `));
-  const indices = answer.split(",").map((s) => parseInt(s.trim(), 10) - 1);
-  return indices.filter((i) => i >= 0 && i < choices.length).map((i) => choices[i].value);
-}
-function detectProjectStructure(rootDir) {
-  const result = {};
-  for (const dir of ["src", "app", "lib", "packages"]) {
-    if (fs.existsSync(path.join(rootDir, dir))) {
-      result.sourceDir = dir;
-      break;
-    }
-  }
-  if (result.sourceDir) {
-    const srcPath = path.join(rootDir, result.sourceDir);
-    try {
-      const entries = fs.readdirSync(srcPath, { withFileTypes: true });
-      result.directories = entries.filter((e) => e.isDirectory()).map((e) => e.name).filter((name) => !name.startsWith(".") && !name.startsWith("_"));
-    } catch {
-    }
-  }
-  return result;
-}
-function generateConfigFromAnswers(answers, projectName) {
-  const config = {
-    version: "1.0",
-    "agent-guidelines": {
-      overview: `${projectName} uses Paradigm for structured AI context management.`,
-      "how-to-use": [
-        "Check .purpose files in directories before making changes",
-        "Run `paradigm status` to see all symbols in the project",
-        "Run `paradigm visualize` to explore the Dreamscape",
-        "Reference symbols using @ # $ % ~ ^ ! ? prefixes"
-      ],
-      "update-rules": [
-        "When adding a feature, create/update the nearest .purpose file",
-        "When adding authorization, update portal.yaml",
-        "When exploring ideas, add to .premise with ? prefix",
-        "Run `paradigm cursorrules` after updating .paradigm"
-      ]
-    },
-    "symbol-system": DEFAULT_SYMBOL_SYSTEM,
-    states: {},
-    "purpose-required": [],
-    conventions: DEFAULT_CONVENTIONS
-  };
-  if (!config.states) config.states = {};
-  if (answers.hasAuth && answers.hasAuth !== "none") {
-    config.states.user = {
-      authenticated: { type: "boolean", default: false, description: "User is logged in" },
-      role: { type: "enum", values: ["guest", "user", "admin"], description: "User access level" }
-    };
-    if (answers.hasAuth === "session") {
-      config.states.user.sessionExpiry = { type: "string", description: "Session expiration time" };
-    }
-  }
-  if (answers.hasSubscription && answers.hasSubscription !== "none") {
-    if (!config.states.user) config.states.user = {};
-    if (answers.hasSubscription === "tiers") {
-      config.states.user.subscription = {
-        type: "enum",
-        values: ["free", "trial", "pro", "enterprise"],
-        description: "Subscription tier"
-      };
-    } else {
-      config.states.user.isPremium = { type: "boolean", default: false, description: "Has premium access" };
-    }
-  }
-  if (answers.hasGates === "yes") {
-    config["agent-guidelines"]["how-to-use"].push(
-      "Check portal.yaml for authorization rules before modifying access control"
-    );
-  }
-  if (answers.directories && answers.directories.length > 0 && answers.sourceDir) {
-    config["purpose-required"] = answers.directories.map((dir) => ({
-      pattern: `${answers.sourceDir}/${dir}/*`,
-      depth: 1
-    }));
-  }
-  if (answers.customStates) {
-    const customParts = answers.customStates.split(",").map((s) => s.trim()).filter(Boolean);
-    for (const custom of customParts) {
-      const parts = custom.split(".");
-      if (parts.length >= 2) {
-        const category = parts[0];
-        const stateName = parts.slice(1).join(".");
-        if (!config.states[category]) {
-          config.states[category] = {};
-        }
-        config.states[category][stateName] = {
-          type: "boolean",
-          description: `Custom state: ${custom}`
-        };
-      }
-    }
-  }
-  return config;
-}
-async function runInteractiveSetup(rootDir) {
-  const rl = createPrompt();
-  const answers = {};
-  console.log(chalk.blue("\n\u{1F305} Paradigm Setup Wizard\n"));
-  console.log(chalk.gray("\u2500".repeat(55)));
-  const detected = detectProjectStructure(rootDir);
-  console.log(chalk.white("\n\u{1F4C2} Detected project structure:"));
-  if (detected.sourceDir) {
-    console.log(chalk.gray(`   Source directory: ${detected.sourceDir}/`));
-  }
-  if (detected.directories?.length) {
-    console.log(chalk.gray(`   Subdirectories: ${detected.directories.slice(0, 5).join(", ")}${detected.directories.length > 5 ? "..." : ""}`));
-  }
-  console.log(chalk.gray("\n\u2500".repeat(55)));
-  console.log(chalk.white("\n\u{1F4C1} Project Structure\n"));
-  answers.sourceDir = await askSelect(rl, "What is your main source directory?", [
-    { name: `${detected.sourceDir || "src"}/ (detected)`, value: detected.sourceDir || "src" },
-    { name: "src/", value: "src" },
-    { name: "app/", value: "app" },
-    { name: "lib/", value: "lib" },
-    { name: "packages/", value: "packages" }
-  ]);
-  answers.directories = await askMultiSelect(rl, "Which directories should have .purpose files?", [
-    { name: "features/ (user-facing capabilities)", value: "features" },
-    { name: "components/ (reusable UI/code)", value: "components" },
-    { name: "services/ (business logic)", value: "services" },
-    { name: "routes/ or api/ (endpoints)", value: "routes" },
-    { name: "pages/ (page components)", value: "pages" },
-    { name: "lib/ (utilities)", value: "lib" }
-  ]);
-  console.log(chalk.gray("\n\u2500".repeat(55)));
-  console.log(chalk.white("\n\u{1F510} State Tracking\n"));
-  answers.hasAuth = await askSelect(rl, "Does your app have user authentication?", [
-    { name: "Yes, with sessions/JWT", value: "session" },
-    { name: "Yes, OAuth only", value: "oauth" },
-    { name: "No authentication", value: "none" }
-  ]);
-  answers.hasSubscription = await askSelect(rl, "Do you have subscription tiers or paid features?", [
-    { name: "Yes (multiple tiers: free, pro, enterprise)", value: "tiers" },
-    { name: "Yes (single paid tier)", value: "single" },
-    { name: "No paid features", value: "none" }
-  ]);
-  console.log(chalk.gray("\n\u2500".repeat(55)));
-  console.log(chalk.white("\n\u{1F6AA} Authorization Gates\n"));
-  answers.hasGates = await askSelect(rl, "Will you use Gate for authorization topology?", [
-    { name: "Yes - I have role-based or feature-gated access", value: "yes" },
-    { name: "No - simple or no authorization", value: "no" }
-  ]);
-  console.log("\n");
-  answers.customStates = await ask(
-    rl,
-    chalk.cyan("Any custom states to track? ") + chalk.gray("(comma-separated, e.g., app.maintenance, cart.items)\n") + chalk.white("> ")
-  );
-  console.log(chalk.gray("\n\u2500".repeat(55)));
-  console.log(chalk.white("\n\u{1F916} Cursor Integration\n"));
-  const hasCursorrules = cursorrrulesExists(rootDir);
-  if (hasCursorrules) {
-    answers.cursorMode = await askSelect(rl, "A .cursorrules file exists. How should we handle it?", [
-      { name: "Append Paradigm section to existing file", value: "append" },
-      { name: "Replace with new .cursorrules", value: "create" },
-      { name: "Skip - do not modify .cursorrules", value: "skip" }
-    ]);
-  } else {
-    answers.cursorMode = await askSelect(rl, "Generate a .cursorrules file for Cursor AI?", [
-      { name: "Yes - create .cursorrules with Paradigm context", value: "create" },
-      { name: "No - skip Cursor integration", value: "skip" }
-    ]);
-  }
-  rl.close();
-  return answers;
-}
-async function setupCommand(targetPath, options) {
-  const rootDir = targetPath ? path.resolve(targetPath) : process.cwd();
-  const projectName = path.basename(rootDir);
-  const paradigmPath = path.join(rootDir, ".paradigm");
-  if (fs.existsSync(paradigmPath) && !options.force) {
-    console.log(chalk.yellow("\n\u26A0\uFE0F  .paradigm already exists in this directory."));
-    console.log(chalk.gray("   Use --force to overwrite, or edit .paradigm directly.\n"));
-    return;
-  }
-  let answers;
-  if (options.yes) {
-    const detected = detectProjectStructure(rootDir);
-    answers = {
-      sourceDir: detected.sourceDir || "src",
-      directories: ["features", "components"],
-      hasAuth: "session",
-      hasSubscription: "none",
-      hasGates: "yes",
-      cursorMode: "create"
-    };
-    console.log(chalk.blue("\n\u{1F305} Using default configuration...\n"));
-  } else {
-    answers = await runInteractiveSetup(rootDir);
-  }
-  const config = generateConfigFromAnswers(answers, projectName);
-  fs.writeFileSync(paradigmPath, serializeParadigmConfig(config), "utf8");
-  console.log(chalk.green("\n\u2705 Created .paradigm configuration"));
-  const premisePath = path.join(rootDir, ".premise");
-  if (!fs.existsSync(premisePath)) {
-    fs.writeFileSync(premisePath, getDefaultPremiseContent(projectName), "utf8");
-    console.log(chalk.green("\u2705 Created .premise file"));
-  }
-  const purposePath = path.join(rootDir, ".purpose");
-  if (!fs.existsSync(purposePath)) {
-    fs.writeFileSync(purposePath, getDefaultPurposeContent(), "utf8");
-    console.log(chalk.green("\u2705 Created .purpose file"));
-  }
-  const gatePath = path.join(rootDir, "portal.yaml");
-  if (answers.hasGates === "yes" && !fs.existsSync(gatePath)) {
-    const { getDefaultGateConfig } = await import("./dist-TA6LSC2Q.js");
-    fs.writeFileSync(gatePath, getDefaultGateConfig(), "utf8");
-    console.log(chalk.green("\u2705 Created portal.yaml"));
-  }
-  const cursorMode = answers.cursorMode || "skip";
-  if (cursorMode !== "skip") {
-    const result = writeCursorrules(rootDir, config, cursorMode, projectName);
-    if (result.success && result.path) {
-      console.log(chalk.green(`\u2705 ${result.message}`));
-    }
-  }
-  console.log(chalk.gray("\n\u2500".repeat(55)));
-  console.log(chalk.blue("\n\u{1F389} Paradigm setup complete!\n"));
-  console.log(chalk.white("Files created:"));
-  console.log(chalk.gray("  \u2022 .paradigm      ") + chalk.white("AI guidelines, symbols, states"));
-  console.log(chalk.gray("  \u2022 .premise        ") + chalk.white("Project overview & ideas"));
-  console.log(chalk.gray("  \u2022 .purpose      ") + chalk.white("Root context & features"));
-  if (answers.hasGates === "yes") {
-    console.log(chalk.gray("  \u2022 portal.yaml     ") + chalk.white("Authorization topology"));
-  }
-  if (cursorMode !== "skip") {
-    console.log(chalk.gray("  \u2022 .cursorrules  ") + chalk.white("Cursor AI integration"));
-  }
-  console.log(chalk.white("\nNext steps:"));
-  console.log(chalk.gray("  1. ") + "Review and customize " + chalk.cyan(".paradigm"));
-  console.log(chalk.gray("  2. ") + "Edit " + chalk.cyan(".purpose") + " to define your project context");
-  console.log(chalk.gray("  3. ") + "Run " + chalk.cyan("paradigm visualize") + " to open the Dreamscape");
-  console.log(chalk.gray("  4. ") + "Run " + chalk.cyan("paradigm cursorrules") + " after changes to regenerate\n");
-}
-export {
-  setupCommand
-};