@a-company/paradigm 3.23.2 → 3.24.0

package/dist/{orchestrate-6XGEA655.js → orchestrate-NNNWNELP.js}

@@ -2,22 +2,22 @@
 import {
   BackgroundOrchestrator,
   Orchestrator
-} from "./chunk-Z42FOOVT.js";
+} from "./chunk-GC6X3YM7.js";
 import "./chunk-6QC3YGB6.js";
-import "./chunk-YOFP72IB.js";
-import "./chunk-XNUWLW73.js";
+import "./chunk-6EQRU7WC.js";
+import "./chunk-PBHIFAL4.js";
+import "./chunk-7WTOOH23.js";
 import {
   loadAgentsManifest
 } from "./chunk-PMXRGPRQ.js";
-import "./chunk-PBHIFAL4.js";
-import "./chunk-6P4IFIK2.js";
-import "./chunk-MRENOFTR.js";
-import "./chunk-IRKUEJVW.js";
-import "./chunk-MW5DMGBB.js";
 import {
   formatCost,
   formatTokens
 } from "./chunk-5JGJACDU.js";
+import "./chunk-6P4IFIK2.js";
+import "./chunk-MRENOFTR.js";
+import "./chunk-IRKUEJVW.js";
+import "./chunk-MW5DMGBB.js";
 import "./chunk-ZXMDA7VB.js";
 
 // src/commands/team/orchestrate.ts

package/dist/pipeline-3G2FRAKM.js

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+import "./chunk-ZXMDA7VB.js";
+
+// src/commands/pipeline/index.ts
+import chalk from "chalk";
+
+// src/core/pipeline-utils.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+
+// src/core/pipeline-types.ts
+var DEFAULT_TEMPLATES = {
+  "add-feature": {
+    gates: { specify: "manual", plan: "manual", task: "auto", implement: "sentinel", validate: "sentinel" },
+    description: "Standard feature addition with manual spec/plan review"
+  },
+  "bug-fix": {
+    gates: { specify: "auto", plan: "auto", task: "auto", implement: "sentinel", validate: "sentinel" },
+    description: "Quick bug fix with automated gates except validation"
+  },
+  "security-change": {
+    gates: { specify: "manual", plan: "manual", task: "manual", implement: "manual", validate: "manual" },
+    description: "Security-sensitive change with all-manual gates"
+  },
+  "refactor": {
+    gates: { specify: "auto", plan: "manual", task: "auto", implement: "sentinel", validate: "sentinel" },
+    description: "Code refactoring with manual plan review"
+  }
+};
+var STAGE_ORDER = ["specify", "plan", "task", "implement", "validate"];
+var PIPELINE_DIR = ".paradigm/pipeline";
+
+// src/core/pipeline-utils.ts
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function loadPipeline(projectDir, feature) {
+  const slug = slugify(feature);
+  const filePath = path.join(projectDir, PIPELINE_DIR, `${slug}.yaml`);
+  if (!fs.existsSync(filePath)) return null;
+  return yaml.load(fs.readFileSync(filePath, "utf8"));
+}
+function savePipeline(projectDir, pipeline) {
+  const slug = slugify(pipeline.feature);
+  const dir = path.join(projectDir, PIPELINE_DIR);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  const filePath = path.join(dir, `${slug}.yaml`);
+  fs.writeFileSync(filePath, yaml.dump(pipeline, { lineWidth: 120 }), "utf8");
+  return filePath;
+}
+function listPipelines(projectDir) {
+  const dir = path.join(projectDir, PIPELINE_DIR);
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir).filter((f) => f.endsWith(".yaml") && !f.startsWith("completed")).map((f) => {
+    try {
+      return yaml.load(fs.readFileSync(path.join(dir, f), "utf8"));
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+}
+function createPipeline(feature, gateConfig, template) {
+  const stages = {
+    specify: { status: "pending" },
+    plan: { status: "pending" },
+    task: { status: "pending" },
+    implement: { status: "pending" },
+    validate: { status: "pending" }
+  };
+  stages.specify.status = "in-progress";
+  return {
+    version: "1.0",
+    feature: slugify(feature),
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    current_stage: "specify",
+    gate_config: gateConfig,
+    template,
+    stages
+  };
+}
+function getNextStage(current) {
+  const idx = STAGE_ORDER.indexOf(current);
+  return idx < STAGE_ORDER.length - 1 ? STAGE_ORDER[idx + 1] : null;
+}
+function archivePipeline(projectDir, pipeline) {
+  const slug = slugify(pipeline.feature);
+  const completedDir = path.join(projectDir, PIPELINE_DIR, "completed");
+  if (!fs.existsSync(completedDir)) fs.mkdirSync(completedDir, { recursive: true });
+  const destPath = path.join(completedDir, `${slug}.yaml`);
+  fs.writeFileSync(destPath, yaml.dump(pipeline, { lineWidth: 120 }), "utf8");
+  const activePath = path.join(projectDir, PIPELINE_DIR, `${slug}.yaml`);
+  if (fs.existsSync(activePath)) fs.unlinkSync(activePath);
+}
+
+// src/commands/pipeline/index.ts
+async function pipelineStartCommand(description, options) {
+  const projectDir = process.cwd();
+  const template = options.template || "add-feature";
+  let gateConfig;
+  if (options.gates) {
+    const parts = options.gates.split(",");
+    if (parts.length !== 5) {
+      console.error(
+        chalk.red("--gates requires 5 comma-separated modes: specify,plan,task,implement,validate")
+      );
+      process.exit(1);
+    }
+    gateConfig = {
+      specify: parts[0],
+      plan: parts[1],
+      task: parts[2],
+      implement: parts[3],
+      validate: parts[4]
+    };
+  } else {
+    const tmpl = DEFAULT_TEMPLATES[template];
+    if (!tmpl) {
+      console.error(
+        chalk.red(
+          `Unknown template: ${template}. Available: ${Object.keys(DEFAULT_TEMPLATES).join(", ")}`
+        )
+      );
+      process.exit(1);
+    }
+    gateConfig = tmpl.gates;
+  }
+  const pipeline = createPipeline(description, gateConfig, template);
+  const filePath = savePipeline(projectDir, pipeline);
+  console.log(chalk.green(`Pipeline created: ${pipeline.feature}`));
+  console.log(chalk.gray(`Template: ${template}`));
+  console.log(
+    chalk.gray(`Gates: ${STAGE_ORDER.map((s) => `${s}=${gateConfig[s]}`).join(", ")}`)
+  );
+  console.log(chalk.gray(`File: ${filePath}`));
+  console.log(chalk.cyan(`
+Current stage: specify (in-progress)`));
+}
+async function pipelineStatusCommand(feature) {
+  const projectDir = process.cwd();
+  if (feature) {
+    const pipeline = loadPipeline(projectDir, feature);
+    if (!pipeline) {
+      console.error(chalk.red(`Pipeline not found: ${feature}`));
+      process.exit(1);
+    }
+    displayPipelineStatus(pipeline);
+  } else {
+    const pipelines = listPipelines(projectDir);
+    if (pipelines.length === 0) {
+      console.log(chalk.gray("No active pipelines"));
+      return;
+    }
+    for (const p of pipelines) {
+      displayPipelineStatus(p);
+      console.log();
+    }
+  }
+}
+function displayPipelineStatus(pipeline) {
+  console.log(chalk.bold(`Pipeline: ${pipeline.feature}`));
+  console.log(chalk.gray(`Created: ${pipeline.created}`));
+  if (pipeline.template) console.log(chalk.gray(`Template: ${pipeline.template}`));
+  console.log();
+  for (const stage of STAGE_ORDER) {
+    const state = pipeline.stages[stage];
+    const gate = pipeline.gate_config[stage];
+    const isCurrent = pipeline.current_stage === stage;
+    const icon = state.status === "approved" ? "+" : state.status === "in-progress" ? ">" : state.status === "blocked" ? "x" : ".";
+    const color = state.status === "approved" ? chalk.green : state.status === "in-progress" ? chalk.cyan : state.status === "blocked" ? chalk.red : chalk.gray;
+    console.log(
+      color(
+        `  ${icon} ${stage.padEnd(12)} [${gate}] ${state.status}${isCurrent ? " <- current" : ""}`
+      )
+    );
+    if (state.artifact) console.log(chalk.gray(`    Artifact: ${state.artifact}`));
+    if (state.symbols_touched?.length)
+      console.log(chalk.gray(`    Symbols: ${state.symbols_touched.join(", ")}`));
+  }
+}
+async function pipelineAdvanceCommand(feature) {
+  const projectDir = process.cwd();
+  const pipeline = loadPipeline(projectDir, feature);
+  if (!pipeline) {
+    console.error(chalk.red(`Pipeline not found: ${feature}`));
+    process.exit(1);
+  }
+  const current = pipeline.current_stage;
+  const gateMode = pipeline.gate_config[current];
+  const next = getNextStage(current);
+  pipeline.stages[current].status = "approved";
+  pipeline.stages[current].approved_at = (/* @__PURE__ */ new Date()).toISOString();
+  if (gateMode === "auto") {
+    pipeline.stages[current].auto_passed_at = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  if (next) {
+    pipeline.current_stage = next;
+    pipeline.stages[next].status = "in-progress";
+    savePipeline(projectDir, pipeline);
+    console.log(chalk.green(`Stage '${current}' approved. Advanced to '${next}'.`));
+  } else {
+    savePipeline(projectDir, pipeline);
+    archivePipeline(projectDir, pipeline);
+    console.log(chalk.green(`Pipeline '${pipeline.feature}' completed and archived.`));
+  }
+}
+async function pipelineConfigureCommand(feature, options) {
+  const projectDir = process.cwd();
+  const pipeline = loadPipeline(projectDir, feature);
+  if (!pipeline) {
+    console.error(chalk.red(`Pipeline not found: ${feature}`));
+    process.exit(1);
+  }
+  const stage = options.stage;
+  if (!STAGE_ORDER.includes(stage)) {
+    console.error(chalk.red(`Invalid stage: ${options.stage}`));
+    process.exit(1);
+  }
+  const gate = options.gate;
+  if (!["auto", "manual", "sentinel"].includes(gate)) {
+    console.error(chalk.red(`Invalid gate mode: ${options.gate}. Use: auto, manual, sentinel`));
+    process.exit(1);
+  }
+  const old = pipeline.gate_config[stage];
+  pipeline.gate_config[stage] = gate;
+  savePipeline(projectDir, pipeline);
+  console.log(chalk.green(`Gate for '${stage}' changed: ${old} -> ${gate}`));
+  if (options.reason) console.log(chalk.gray(`Reason: ${options.reason}`));
+}
+async function pipelineAbortCommand(feature) {
+  const projectDir = process.cwd();
+  const pipeline = loadPipeline(projectDir, feature);
+  if (!pipeline) {
+    console.error(chalk.red(`Pipeline not found: ${feature}`));
+    process.exit(1);
+  }
+  archivePipeline(projectDir, pipeline);
+  console.log(chalk.yellow(`Pipeline '${pipeline.feature}' aborted and archived.`));
+}
+async function pipelineListCommand() {
+  const projectDir = process.cwd();
+  const pipelines = listPipelines(projectDir);
+  if (pipelines.length === 0) {
+    console.log(chalk.gray("No active pipelines."));
+    return;
+  }
+  console.log(chalk.bold(`Active Pipelines (${pipelines.length}):
+`));
+  for (const p of pipelines) {
+    const completedStages = STAGE_ORDER.filter((s) => p.stages[s].status === "approved").length;
+    console.log(
+      `  ${chalk.cyan(p.feature)} -- stage ${completedStages}/${STAGE_ORDER.length} (${p.current_stage})`
+    );
+  }
+}
+export {
+  pipelineAbortCommand,
+  pipelineAdvanceCommand,
+  pipelineConfigureCommand,
+  pipelineListCommand,
+  pipelineStartCommand,
+  pipelineStatusCommand
+};

package/dist/{probe-T77FFIAG.js → probe-SN4BNXOC.js}

@@ -2,7 +2,7 @@
 import {
   generateFlowIndex,
   generateNavigator
-} from "./chunk-UI3XXVJ6.js";
+} from "./chunk-W4VFKZVF.js";
 import {
   generateScanIndex,
   serializeScanIndex
@@ -12,6 +12,7 @@ import {
 } from "./chunk-6P4IFIK2.js";
 import "./chunk-MRENOFTR.js";
 import "./chunk-IRKUEJVW.js";
+import "./chunk-Z7W7HNRG.js";
 import {
   parseParadigmConfig
 } from "./chunk-YO6DVTL7.js";

package/dist/{providers-VIBWDN5D.js → providers-NKGY36QF.js}

@@ -4,7 +4,7 @@ import {
   getBestProvider,
   getConfiguredProvider,
   setConfiguredProvider
-} from "./chunk-XNUWLW73.js";
+} from "./chunk-7WTOOH23.js";
 import "./chunk-ZXMDA7VB.js";
 
 // src/commands/team/providers.ts

package/dist/{shift-SW3GSODO.js → shift-G42AEUHE.js}

@@ -1,47 +1,48 @@
 #!/usr/bin/env node
 import {
   teamInitCommand
-} from "./chunk-XKAFTZOZ.js";
-import "./chunk-Z42FOOVT.js";
+} from "./chunk-VHSTF72C.js";
+import "./chunk-GC6X3YM7.js";
 import "./chunk-6QC3YGB6.js";
-import "./chunk-YOFP72IB.js";
-import "./chunk-XNUWLW73.js";
+import "./chunk-6EQRU7WC.js";
+import "./chunk-PBHIFAL4.js";
+import "./chunk-7WTOOH23.js";
 import {
   agentsConfigured
 } from "./chunk-PMXRGPRQ.js";
-import "./chunk-PBHIFAL4.js";
 import {
   hooksInstallCommand
 } from "./chunk-DS5QY37M.js";
 import {
   detectProjectRole
-} from "./chunk-C3BK3E23.js";
+} from "./chunk-OXG5GVDJ.js";
+import {
+  doctorCommand
+} from "./chunk-4UC6AQOC.js";
+import "./chunk-5JGJACDU.js";
 import {
   initCommand
-} from "./chunk-K34C7NAN.js";
+} from "./chunk-6UV47VRD.js";
 import {
   detectDiscipline
 } from "./chunk-CHSHON3O.js";
 import {
   indexCommand
-} from "./chunk-UI3XXVJ6.js";
+} from "./chunk-W4VFKZVF.js";
 import "./chunk-AK5M6KJB.js";
 import "./chunk-6P4IFIK2.js";
 import "./chunk-MRENOFTR.js";
 import "./chunk-IRKUEJVW.js";
+import "./chunk-Z7W7HNRG.js";
 import {
   syncCommand
 } from "./chunk-RP6TZYGE.js";
-import "./chunk-MW5DMGBB.js";
-import {
-  doctorCommand
-} from "./chunk-ZMN3RAIT.js";
 import "./chunk-KB4XJWE3.js";
 import "./chunk-YO6DVTL7.js";
 import {
   log
 } from "./chunk-4NCFWYGG.js";
-import "./chunk-5JGJACDU.js";
+import "./chunk-MW5DMGBB.js";
 import "./chunk-ZXMDA7VB.js";
 
 // src/commands/shift.ts
@@ -251,7 +252,7 @@ workspace: "${relPath}"
         if (configForWs.workspace) {
           spinner.start("Step 3b/6: Reindexing workspace members...");
           try {
-            const { workspaceReindexCommand } = await import("./workspace-S5Q5LVA6.js");
+            const { workspaceReindexCommand } = await import("./workspace-L27RR5MF.js");
             await workspaceReindexCommand({ quiet: true });
             spinner.succeed(chalk.green("Workspace members reindexed"));
           } catch (e) {

package/dist/{spawn-JSV2HST3.js → spawn-52PASJJL.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import {
   AgentSpawner
-} from "./chunk-YOFP72IB.js";
+} from "./chunk-6EQRU7WC.js";
+import "./chunk-PBHIFAL4.js";
 import {
   getBestProvider
-} from "./chunk-XNUWLW73.js";
+} from "./chunk-7WTOOH23.js";
 import {
   loadAgentsManifest
 } from "./chunk-PMXRGPRQ.js";
-import "./chunk-PBHIFAL4.js";
 import {
   formatTokens
 } from "./chunk-5JGJACDU.js";