@a-company/paradigm 1.5.0

package/README.md

@@ -0,0 +1,142 @@
+# @a-company/paradigm
+
+> Universal Agentic Development Protocol - Language & Discipline Agnostic
+
+Paradigm is the **blueprint for AI-assisted development** that works across any tech stack, language, or discipline. Whether you're building a web app, training an ML model, writing firmware, or deploying infrastructure - Paradigm provides the same consistent context protocol.
+
+## Installation
+
+```bash
+npm install -g @a-company/paradigm
+```
+
+## Quick Start
+
+```bash
+# Initialize Paradigm in your project
+paradigm init
+
+# Full setup: init + team + scan + sync all IDEs
+paradigm shift
+
+# Check project status
+paradigm status
+
+# Health check
+paradigm doctor
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `paradigm init` | Initialize Paradigm in current project |
+| `paradigm shift` | Full setup: init + team + scan + sync all IDEs |
+| `paradigm sync` | Regenerate IDE instruction files |
+| `paradigm scan` | Rebuild scan index |
+| `paradigm status` | Show project overview |
+| `paradigm doctor` | Health check and diagnostics |
+| `paradigm team init` | Initialize multi-agent configuration |
+| `paradigm team agents suggest` | Suggest agents for a task |
+| `paradigm team orchestrate` | Run multi-agent orchestration |
+
+### IDE Sync
+
+Sync to specific IDEs:
+
+```bash
+paradigm sync cursor      # Generate .cursor/rules/*.mdc
+paradigm sync copilot     # Generate .github/copilot-instructions.md
+paradigm sync windsurf    # Generate .windsurfrules
+paradigm sync claude      # Generate CLAUDE.md
+paradigm sync --all       # Generate all IDE files
+```
+
+### Purpose Commands
+
+```bash
+paradigm purpose validate    # Validate .purpose files
+paradigm purpose remember    # Show context for a path
+```
+
+### Portal Commands
+
+```bash
+paradigm portal validate     # Validate portal.yaml
+paradigm portal test         # Run gate tests
+```
+
+### Premise Commands
+
+```bash
+paradigm premise aggregate   # Aggregate all symbols
+paradigm premise snapshot    # Save current state
+```
+
+## Symbol System (v2)
+
+5 operational symbols for code structure + a tag bank for classification:
+
+| Symbol | Name | Description |
+|--------|------|-------------|
+| `#` | Component | Any documented code unit (features, services, UI, utils) |
+| `$` | Flow | Multi-step processes or user journeys |
+| `^` | Gate | Access control points and authorization rules |
+| `!` | Signal | Events, errors, and side effects |
+| `~` | Aspect | Cross-cutting rules with required code anchors |
+
+### Tag Bank
+
+Instead of dedicated symbol prefixes, classify with tags:
+
+| Tag | Purpose | Example |
+|-----|---------|---------|
+| `[feature]` | User-facing capability | `#checkout` with `tags: [feature]` |
+| `[integration]` | External service | `#stripe-service` with `tags: [integration, stripe]` |
+| `[state]` | State management | `#user-store` with `tags: [state]` |
+| `[idea]` | Future possibility | Any symbol with `tags: [idea]` |
+| `[deprecated]` | Marked for removal | Any symbol with `tags: [deprecated]` |
+
+## Supported Disciplines
+
+Paradigm's symbol system is universal. The same symbols work across:
+
+| Discipline | Component `#` | Gate `^` | Signal `!` |
+|------------|---------------|----------|------------|
+| Web | `#checkout` | `^authenticated` | `!payment-completed` |
+| Backend | `#user-service` | `^admin` | `!user-created` |
+| ML | `#classifier-v2` | `^model-validated` | `!training-complete` |
+| Mobile | `#home-screen` | `^biometric-auth` | `!push-received` |
+| Game | `#attack-system` | `^level-unlocked` | `!enemy-defeated` |
+| Embedded | `#spi-driver` | `^calibrated` | `!sensor-read` |
+| DevOps | `#vpc-module` | `^deploy-approved` | `!deploy-complete` |
+
+See `specs/disciplines.md` for complete mappings.
+
+## Project Structure
+
+When initialized, Paradigm creates:
+
+```
+.paradigm/
+├── config.yaml          # Main configuration + discipline setting
+├── tags.yaml            # Tag bank definitions
+├── specs/
+│   ├── symbols-v2.md    # Symbol system reference
+│   ├── disciplines.md   # Discipline-specific mappings
+│   ├── logger.md        # Logging specification
+│   └── scan.md          # Visual discovery protocol
+├── docs/
+│   ├── commands.md      # CLI reference
+│   ├── patterns.md      # Coding patterns
+│   └── troubleshooting.md
+└── agents.yaml          # Multi-agent configuration
+```
+
+## Documentation
+
+See the [main repository](https://github.com/ascend42/a-paradigm) for full documentation.
+
+## License
+
+MIT

package/dist/accept-orchestration-CWZNCGZX.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+import {
+  BackgroundOrchestrator
+} from "./chunk-AD2LSCHB.js";
+import "./chunk-6QC3YGB6.js";
+import "./chunk-WS5KM7OL.js";
+import "./chunk-PBHIFAL4.js";
+import "./chunk-TAP5N3HH.js";
+import "./chunk-PMXRGPRQ.js";
+import "./chunk-5C4SGQKH.js";
+import "./chunk-PW2EXJQT.js";
+import "./chunk-IRKUEJVW.js";
+import "./chunk-5JGJACDU.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/team/accept-orchestration.ts
+import * as path from "path";
+import chalk from "chalk";
+async function teamAcceptOrchestrationCommand(orchestrationId, targetPath, options) {
+  const rootDir = targetPath ? path.resolve(targetPath) : process.cwd();
+  if (!orchestrationId) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Orchestration ID required" }));
+    } else {
+      console.log(chalk.red("\nOrchestration ID required."));
+      console.log(chalk.gray("Usage: paradigm team accept <orchestration-id>\n"));
+    }
+    return;
+  }
+  const bgOrchestrator = new BackgroundOrchestrator(rootDir);
+  const orch = bgOrchestrator.getOrchestration(orchestrationId);
+  if (!orch) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Orchestration not found", id: orchestrationId }));
+    } else {
+      console.log(chalk.red(`
+Orchestration not found: ${orchestrationId}
+`));
+    }
+    return;
+  }
+  if (orch.status !== "completed") {
+    if (options.json) {
+      console.log(JSON.stringify({
+        error: "Cannot accept orchestration",
+        reason: `Status is '${orch.status}', expected 'completed'`
+      }));
+    } else {
+      console.log(chalk.red(`
+Cannot accept orchestration in '${orch.status}' status.`));
+      console.log(chalk.gray("Only completed orchestrations can be accepted.\n"));
+    }
+    return;
+  }
+  try {
+    await bgOrchestrator.accept(orchestrationId, { note: options.note });
+    if (options.json) {
+      console.log(JSON.stringify({
+        success: true,
+        id: orchestrationId,
+        status: "accepted",
+        artifacts: orch.artifacts.length
+      }));
+      return;
+    }
+    console.log();
+    console.log(chalk.green("\u2501".repeat(60)));
+    console.log(chalk.green(`  \u2713 Orchestration Accepted`));
+    console.log(chalk.green("\u2501".repeat(60)));
+    console.log();
+    console.log(chalk.white(`  ID: ${orchestrationId}`));
+    console.log(chalk.gray(`  Task: ${orch.task.slice(0, 50)}${orch.task.length > 50 ? "..." : ""}`));
+    if (options.note) {
+      console.log(chalk.gray(`  Note: ${options.note}`));
+    }
+    console.log();
+    if (orch.artifacts.length > 0) {
+      console.log(chalk.cyan("  Artifacts accepted:"));
+      for (const artifact of orch.artifacts) {
+        const icon = artifact.action === "created" ? chalk.green("+") : artifact.action === "modified" ? chalk.yellow("~") : chalk.red("-");
+        console.log(`    ${icon} ${artifact.path}`);
+      }
+      console.log();
+    }
+    if (orch.parallelBuilderStats) {
+      console.log(chalk.cyan("  Parallel builder stats:"));
+      console.log(chalk.gray(`    Sub-phases: ${orch.parallelBuilderStats.totalSubPhases}`));
+      console.log(chalk.gray(`    Parallel builders: ${orch.parallelBuilderStats.totalParallelBuilders}`));
+      console.log(chalk.gray(`    Files created: ${orch.parallelBuilderStats.filesCreated}`));
+      console.log();
+    }
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        error: error instanceof Error ? error.message : String(error)
+      }));
+    } else {
+      console.log(chalk.red(`
+Error: ${error instanceof Error ? error.message : error}
+`));
+    }
+  }
+}
+async function teamRejectOrchestrationCommand(orchestrationId, targetPath, options) {
+  const rootDir = targetPath ? path.resolve(targetPath) : process.cwd();
+  if (!orchestrationId) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Orchestration ID required" }));
+    } else {
+      console.log(chalk.red("\nOrchestration ID required."));
+      console.log(chalk.gray("Usage: paradigm team reject <orchestration-id>\n"));
+    }
+    return;
+  }
+  const bgOrchestrator = new BackgroundOrchestrator(rootDir);
+  const orch = bgOrchestrator.getOrchestration(orchestrationId);
+  if (!orch) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Orchestration not found", id: orchestrationId }));
+    } else {
+      console.log(chalk.red(`
+Orchestration not found: ${orchestrationId}
+`));
+    }
+    return;
+  }
+  if (orch.status !== "completed") {
+    if (options.json) {
+      console.log(JSON.stringify({
+        error: "Cannot reject orchestration",
+        reason: `Status is '${orch.status}', expected 'completed'`
+      }));
+    } else {
+      console.log(chalk.red(`
+Cannot reject orchestration in '${orch.status}' status.`));
+      console.log(chalk.gray("Only completed orchestrations can be rejected.\n"));
+    }
+    return;
+  }
+  try {
+    await bgOrchestrator.reject(orchestrationId, {
+      reason: options.reason,
+      cleanup: options.cleanup
+    });
+    if (options.json) {
+      console.log(JSON.stringify({
+        success: true,
+        id: orchestrationId,
+        status: "rejected",
+        cleanup: options.cleanup || false
+      }));
+      return;
+    }
+    console.log();
+    console.log(chalk.red("\u2501".repeat(60)));
+    console.log(chalk.red(`  \u2717 Orchestration Rejected`));
+    console.log(chalk.red("\u2501".repeat(60)));
+    console.log();
+    console.log(chalk.white(`  ID: ${orchestrationId}`));
+    console.log(chalk.gray(`  Task: ${orch.task.slice(0, 50)}${orch.task.length > 50 ? "..." : ""}`));
+    if (options.reason) {
+      console.log(chalk.gray(`  Reason: ${options.reason}`));
+    }
+    console.log();
+    if (options.cleanup && orch.artifacts.length > 0) {
+      console.log(chalk.yellow("  Files cleaned up:"));
+      const created = orch.artifacts.filter((a) => a.action === "created");
+      for (const artifact of created) {
+        console.log(chalk.gray(`    - ${artifact.path}`));
+      }
+      console.log();
+    }
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        error: error instanceof Error ? error.message : String(error)
+      }));
+    } else {
+      console.log(chalk.red(`
+Error: ${error instanceof Error ? error.message : error}
+`));
+    }
+  }
+}
+export {
+  teamAcceptOrchestrationCommand,
+  teamRejectOrchestrationCommand
+};

package/dist/agents-suggest-35LIQKDH.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import {
+  suggestAgentsForTask
+} from "./chunk-6QC3YGB6.js";
+import {
+  loadAgentsManifest
+} from "./chunk-PMXRGPRQ.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/team/agents-suggest.ts
+import chalk from "chalk";
+async function agentsSuggestCommand(task, options) {
+  const rootDir = process.cwd();
+  const manifest = loadAgentsManifest(rootDir);
+  if (!manifest) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "No agents.yaml found" }));
+    } else {
+      console.log(
+        chalk.red("\nNo agents.yaml found. Run `paradigm team init` first.\n")
+      );
+    }
+    process.exit(1);
+  }
+  const suggestions = suggestAgentsForTask(task, manifest.agents);
+  if (options.json) {
+    console.log(JSON.stringify({ task, suggestions }, null, 2));
+    return;
+  }
+  console.log(chalk.cyan("\nSuggested agents for this task:\n"));
+  console.log(chalk.gray(`  Task: "${task}"
+`));
+  if (suggestions.length === 0) {
+    console.log(
+      chalk.yellow("  No agents matched. Consider using architect \u2192 builder flow.\n")
+    );
+    console.log(chalk.gray("  Tip: Add keyword or symbol triggers to agents.yaml\n"));
+    return;
+  }
+  for (const suggestion of suggestions) {
+    const icon = suggestion.confidence === "high" ? chalk.green("\u2605") : suggestion.confidence === "medium" ? chalk.yellow("\u25C6") : chalk.gray("\u25CB");
+    console.log(
+      `  ${icon} ${chalk.white.bold(suggestion.name)} ${chalk.gray(`(${suggestion.confidence})`)}`
+    );
+    console.log(chalk.gray(`    ${suggestion.reason}`));
+    console.log(
+      chalk.gray(`    Matched: ${suggestion.triggers_matched.join(", ")}
+`)
+    );
+  }
+  if (suggestions.length > 0) {
+    console.log(chalk.cyan("  Suggested workflow:"));
+    const agents = suggestions.map((s) => s.name);
+    const orderedAgents = reorderToStandardFlow(agents);
+    console.log(chalk.gray(`    ${orderedAgents.join(" \u2192 ")}
+`));
+    console.log(chalk.gray("  Or use MCP orchestration:"));
+    console.log(
+      chalk.gray(
+        `    paradigm_orchestrate_inline({ task: "${task.slice(0, 30)}${task.length > 30 ? "..." : ""}", mode: "plan" })
+`
+      )
+    );
+  }
+}
+function reorderToStandardFlow(agents) {
+  const order = ["architect", "security", "builder", "reviewer", "tester"];
+  const result = [];
+  const remaining = new Set(agents);
+  for (const agent of order) {
+    if (remaining.has(agent)) {
+      result.push(agent);
+      remaining.delete(agent);
+    }
+  }
+  for (const agent of remaining) {
+    result.push(agent);
+  }
+  return result;
+}
+export {
+  agentsSuggestCommand
+};

package/dist/aggregate-W7Q6VIM2.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import {
+  aggregateFromDirectory,
+  aggregateFromPremise,
+  buildSymbolIndex,
+  getSymbolCounts,
+  parsePremiseFile
+} from "./chunk-5C4SGQKH.js";
+import "./chunk-PW2EXJQT.js";
+import "./chunk-IRKUEJVW.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/premise/aggregate.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import ora from "ora";
+async function premiseAggregateCommand(targetPath) {
+  const cwd = process.cwd();
+  const absolutePath = path.resolve(cwd, targetPath);
+  console.log(chalk.blue("\n\u{1F52E} Aggregating Premise...\n"));
+  const spinner = ora("Loading sources...").start();
+  try {
+    let result;
+    const premisePath = path.join(absolutePath, ".premise");
+    if (fs.existsSync(premisePath)) {
+      const { data, errors } = parsePremiseFile(premisePath);
+      if (errors.length > 0) {
+        spinner.warn("Warnings parsing .premise file");
+        for (const error of errors) {
+          console.log(chalk.yellow(`  \u26A0 ${error}`));
+        }
+        console.log(chalk.gray("  Falling back to directory aggregation...\n"));
+      }
+      if (data && !errors.some((e) => e.includes("Required"))) {
+        try {
+          result = await aggregateFromPremise(data, absolutePath);
+        } catch (error) {
+          console.log(chalk.yellow(`  \u26A0 Error using .premise file: ${error.message}`));
+          console.log(chalk.gray("  Falling back to directory aggregation...\n"));
+        }
+      }
+    }
+    if (!result) {
+      result = await aggregateFromDirectory(absolutePath);
+    }
+    spinner.succeed("Aggregated all sources");
+    const index = buildSymbolIndex(result);
+    const counts = getSymbolCounts(index);
+    console.log(chalk.white("\nSources"));
+    console.log(chalk.gray("\u2500".repeat(40)));
+    console.log(`  Purpose files:  ${chalk.cyan(result.purposeFiles.length.toString())}`);
+    console.log(`  Gate files:     ${chalk.cyan(result.portalFiles.length.toString())}`);
+    console.log(chalk.white("\nSymbol Index"));
+    console.log(chalk.gray("\u2500".repeat(40)));
+    const symbolLines = [
+      { prefix: "#", name: "Components", count: counts.component, color: chalk.green },
+      { prefix: "$", name: "Flows", count: counts.flow, color: chalk.yellow },
+      { prefix: "^", name: "Gates", count: counts.gate, color: chalk.red },
+      { prefix: "!", name: "Signals", count: counts.signal, color: chalk.cyan },
+      { prefix: "~", name: "Aspects", count: counts.aspect, color: chalk.magenta }
+    ];
+    for (const { prefix, name, count, color } of symbolLines) {
+      if (count > 0) {
+        console.log(`  ${color(prefix)} ${name.padEnd(12)} ${chalk.cyan(count.toString())}`);
+      }
+    }
+    const total = Object.values(counts).reduce((a, b) => a + b, 0);
+    console.log(chalk.gray("\u2500".repeat(40)));
+    console.log(`  Total:          ${chalk.cyan(total.toString())}`);
+    if (result.errors.length > 0) {
+      console.log(chalk.yellow("\nErrors"));
+      console.log(chalk.gray("\u2500".repeat(40)));
+      for (const error of result.errors) {
+        console.log(chalk.red(`  \u2717 [${error.source}] ${error.filePath}: ${error.message}`));
+      }
+    }
+    console.log("");
+  } catch (error) {
+    spinner.fail("Aggregation failed");
+    console.log(chalk.red(`Error: ${error.message}
+`));
+    process.exit(1);
+  }
+}
+export {
+  premiseAggregateCommand
+};