@a-company/paradigm 1.5.0

package/dist/lint-HXKTWRNO.js

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+import {
+  findPurposeFiles,
+  parsePurposeFileDetailed,
+  serializePurposeFile,
+  validatePurposeFile
+} from "./chunk-PW2EXJQT.js";
+import {
+  log
+} from "./chunk-4NCFWYGG.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/lint.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import ora from "ora";
+function getSuggestion(error) {
+  const msg = error.message.toLowerCase();
+  if (msg.includes("expected object, received array") && error.path?.includes("features")) {
+    return 'Convert to object format: features: { feature-name: { description: "..." } }';
+  }
+  if (msg.includes("expected object, received array") && error.path?.includes("components")) {
+    return 'Convert to object format: components: { component-name: { description: "..." } }';
+  }
+  if (msg.includes("has no description")) {
+    return "Add a description field to help AI understand this item";
+  }
+  if (msg.includes("should use alphanumeric")) {
+    return "Use kebab-case: my-feature-name (lowercase, hyphens)";
+  }
+  if (msg.includes("references unknown")) {
+    return "Define the symbol in a .purpose file or remove the reference";
+  }
+  if (msg.includes("yaml syntax") || msg.includes("bad indentation")) {
+    return "Check indentation (use 2 spaces) and YAML syntax";
+  }
+  return void 0;
+}
+function isMarkdownFormat(content) {
+  const lines = content.trim().split("\n");
+  const hasMarkdownHeader = lines.some((l) => /^#+\s/.test(l));
+  const hasNoYamlStructure = !content.includes(":") || lines[0].startsWith("#") || lines[0].startsWith("@");
+  return hasMarkdownHeader || hasNoYamlStructure && !content.trim().startsWith("---");
+}
+function convertMarkdownToYaml(content, filePath) {
+  const lines = content.trim().split("\n");
+  const dirName = path.basename(path.dirname(filePath));
+  let description = "";
+  for (const line of lines) {
+    if (!line.startsWith("#") && !line.startsWith("@") && line.trim()) {
+      description = line.trim();
+      break;
+    }
+    if (line.startsWith("#")) {
+      description = line.replace(/^#+\s*/, "").trim();
+    }
+  }
+  return `# Auto-converted from markdown format
+description: "${description || `Purpose file for ${dirName}`}"
+
+# TODO: Add features and components
+# features:
+#   feature-name:
+#     description: "What this feature does"
+
+# components:
+#   component-name:
+#     description: "What this component does"
+`;
+}
+function autoQuoteSpecialChars(content) {
+  return content.replace(
+    /\[\s*([^\]]+)\s*\]/g,
+    (_match, arrayContent) => {
+      const items = arrayContent.split(",").map((item) => {
+        const trimmed = item.trim();
+        if (/^[#@$^!%]/.test(trimmed) && !trimmed.startsWith('"') && !trimmed.startsWith("'")) {
+          return `"${trimmed}"`;
+        }
+        return trimmed;
+      });
+      return `[${items.join(", ")}]`;
+    }
+  );
+}
+function attemptFix(filePath, errors) {
+  try {
+    let content = fs.readFileSync(filePath, "utf8");
+    let modified = false;
+    if (isMarkdownFormat(content)) {
+      content = convertMarkdownToYaml(content, filePath);
+      modified = true;
+    }
+    const hasUnquotedSymbols = errors.some(
+      (e) => e.message.includes("tag suffix") || e.message.includes("flow indicator") || e.message.includes("missed comma")
+    );
+    if (hasUnquotedSymbols || content.match(/\[[^\]]*[#@$^!%][^\]"']*\]/)) {
+      const quoted = autoQuoteSpecialChars(content);
+      if (quoted !== content) {
+        content = quoted;
+        modified = true;
+      }
+    }
+    if (modified) {
+      const tempPath = filePath + ".tmp";
+      fs.writeFileSync(tempPath, content);
+      const result2 = parsePurposeFileDetailed(tempPath);
+      fs.unlinkSync(tempPath);
+      if (result2.isYamlValid && result2.data) {
+        return serializePurposeFile(result2.data);
+      }
+      return content;
+    }
+    const result = parsePurposeFileDetailed(filePath);
+    if (result.isYamlValid && result.data) {
+      const fixed = serializePurposeFile(result.data);
+      if (fixed.trim() !== content.trim()) {
+        return fixed;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function lintFile(filePath, rootDir, options) {
+  const relativePath = path.relative(rootDir, filePath);
+  const errors = [];
+  const warnings = [];
+  let fixed = false;
+  const parseResult = parsePurposeFileDetailed(filePath);
+  for (const error of parseResult.detailedErrors || []) {
+    const issue = {
+      message: error.message,
+      line: error.line,
+      path: error.path,
+      type: error.type === "yaml" || error.type === "file" ? "error" : "error",
+      suggestion: getSuggestion(error),
+      fixable: error.type === "schema"
+      // Schema errors might be fixable
+    };
+    errors.push(issue);
+  }
+  if (parseResult.data) {
+    const validationResult = validatePurposeFile(parseResult.data, relativePath);
+    for (const issue of validationResult.issues) {
+      const lintIssue = {
+        message: issue.message,
+        path: issue.path,
+        type: issue.type,
+        suggestion: getSuggestion(issue),
+        fixable: false
+      };
+      if (issue.type === "error") {
+        errors.push(lintIssue);
+      } else {
+        warnings.push(lintIssue);
+      }
+    }
+  }
+  if (options.fix && errors.length > 0) {
+    const fixedContent = attemptFix(filePath, errors);
+    if (fixedContent) {
+      fs.writeFileSync(filePath, fixedContent);
+      fixed = true;
+      const reparse = parsePurposeFileDetailed(filePath);
+      if (reparse.detailedErrors && reparse.detailedErrors.length < errors.length) {
+        errors.length = 0;
+        warnings.length = 0;
+        for (const error of reparse.detailedErrors || []) {
+          errors.push({
+            message: error.message,
+            line: error.line,
+            path: error.path,
+            type: "error",
+            suggestion: getSuggestion(error)
+          });
+        }
+      }
+    }
+  }
+  const valid = errors.length === 0 && (!options.strict || warnings.length === 0);
+  return {
+    path: filePath,
+    relativePath,
+    valid,
+    errors,
+    warnings,
+    fixed
+  };
+}
+function formatIssue(issue, indent = "  ") {
+  const lines = [];
+  const icon = issue.type === "error" ? chalk.red("\u2717") : chalk.yellow("\u26A0");
+  const lineInfo = issue.line ? chalk.gray(` (line ${issue.line})`) : "";
+  const pathInfo = issue.path ? chalk.gray(` at ${issue.path}`) : "";
+  lines.push(`${indent}${icon} ${issue.message}${lineInfo}${pathInfo}`);
+  if (issue.suggestion) {
+    lines.push(`${indent}  ${chalk.cyan("\u2192")} ${chalk.gray(issue.suggestion)}`);
+  }
+  return lines;
+}
+async function lintCommand(targetPath, options) {
+  const rootDir = targetPath ? path.resolve(targetPath) : process.cwd();
+  const spinner = ora();
+  if (!options.quiet && !options.json) {
+    console.log(chalk.blue("\n\u{1F50D} Paradigm Lint\n"));
+  }
+  const tracker = log.command("lint").start("Linting purpose files", { fix: !!options.fix });
+  spinner.start("Finding .purpose files...");
+  const files = await findPurposeFiles(rootDir);
+  spinner.stop();
+  log.operation("find-files").debug("Purpose files found", { count: files.length });
+  if (files.length === 0) {
+    if (options.json) {
+      console.log(JSON.stringify({ files: [], summary: { totalFiles: 0 } }));
+    } else if (!options.quiet) {
+      console.log(chalk.yellow("No .purpose files found.\n"));
+      console.log(chalk.gray("Run `paradigm init` to create your first .purpose file.\n"));
+    }
+    return;
+  }
+  if (!options.quiet && !options.json) {
+    console.log(chalk.gray(`Checking ${files.length} .purpose file${files.length > 1 ? "s" : ""}...
+`));
+  }
+  const results = [];
+  for (const file of files) {
+    const result = lintFile(file, rootDir, options);
+    results.push(result);
+    if (!options.quiet && !options.json) {
+      if (!result.valid || result.errors.length > 0 || result.warnings.length > 0) {
+        const icon = result.errors.length > 0 ? chalk.red("\u2717") : result.warnings.length > 0 ? chalk.yellow("\u26A0") : chalk.green("\u2713");
+        const fixedBadge = result.fixed ? chalk.cyan(" [fixed]") : "";
+        console.log(`${icon} ${result.relativePath}${fixedBadge}`);
+        for (const error of result.errors) {
+          for (const line of formatIssue(error)) {
+            console.log(line);
+          }
+        }
+        for (const warning of result.warnings) {
+          for (const line of formatIssue(warning)) {
+            console.log(line);
+          }
+        }
+        console.log("");
+      }
+    }
+  }
+  const summary = {
+    totalFiles: results.length,
+    validFiles: results.filter((r) => r.valid).length,
+    filesWithErrors: results.filter((r) => r.errors.length > 0).length,
+    filesWithWarnings: results.filter((r) => r.warnings.length > 0).length,
+    totalErrors: results.reduce((sum, r) => sum + r.errors.length, 0),
+    totalWarnings: results.reduce((sum, r) => sum + r.warnings.length, 0),
+    fixedFiles: results.filter((r) => r.fixed).length
+  };
+  if (options.json) {
+    const output = {
+      files: results.map((r) => ({
+        path: r.relativePath,
+        valid: r.valid,
+        errors: r.errors,
+        warnings: r.warnings,
+        fixed: r.fixed
+      })),
+      summary
+    };
+    console.log(JSON.stringify(output, null, 2));
+    process.exit(summary.filesWithErrors > 0 ? 1 : 0);
+    return;
+  }
+  if (!options.quiet) {
+    console.log(chalk.gray("\u2500".repeat(40)));
+    if (summary.totalErrors === 0 && summary.totalWarnings === 0) {
+      console.log(chalk.green(`
+\u2713 All ${summary.totalFiles} file${summary.totalFiles > 1 ? "s" : ""} valid
+`));
+      tracker.success("All files valid", { files: summary.totalFiles });
+    } else {
+      tracker.error("Files have issues", {
+        errors: summary.totalErrors,
+        warnings: summary.totalWarnings,
+        fixed: summary.fixedFiles
+      });
+      console.log("");
+      if (summary.validFiles > 0) {
+        console.log(chalk.green(`\u2713 ${summary.validFiles} file${summary.validFiles > 1 ? "s" : ""} valid`));
+      }
+      if (summary.filesWithErrors > 0) {
+        console.log(chalk.red(`\u2717 ${summary.filesWithErrors} file${summary.filesWithErrors > 1 ? "s" : ""} with errors (${summary.totalErrors} total)`));
+      }
+      if (summary.filesWithWarnings > 0) {
+        console.log(chalk.yellow(`\u26A0 ${summary.filesWithWarnings} file${summary.filesWithWarnings > 1 ? "s" : ""} with warnings (${summary.totalWarnings} total)`));
+      }
+      if (summary.fixedFiles > 0) {
+        console.log(chalk.cyan(`\u21BB ${summary.fixedFiles} file${summary.fixedFiles > 1 ? "s" : ""} auto-fixed`));
+      }
+      console.log("");
+      if (summary.totalErrors > 0 && !options.fix) {
+        console.log(chalk.gray("Run `paradigm lint --fix` to auto-fix where possible.\n"));
+      }
+    }
+  }
+  if (summary.filesWithErrors > 0) {
+    process.exit(1);
+  }
+  if (options.strict && summary.filesWithWarnings > 0) {
+    process.exit(1);
+  }
+}
+export {
+  lintCommand
+};

package/dist/manual-Y3QOXWYA.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+import {
+  MODEL_PRICING
+} from "./chunk-5JGJACDU.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/core/providers/manual.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+var ManualProvider = class {
+  name = "manual";
+  rootDir;
+  constructor(rootDir = process.cwd()) {
+    this.rootDir = rootDir;
+  }
+  listModels() {
+    return ["opus", "sonnet", "haiku"];
+  }
+  supportsParallel() {
+    return false;
+  }
+  supportsMcp() {
+    return true;
+  }
+  getTokenCost(model) {
+    return MODEL_PRICING[model];
+  }
+  async isAvailable() {
+    return true;
+  }
+  /**
+   * Create a handoff file for manual execution
+   */
+  async *spawn(agent, options) {
+    const handoffsDir = path.join(this.rootDir, ".paradigm", "handoffs");
+    const tasksDir = path.join(this.rootDir, ".paradigm", "tasks");
+    for (const dir of [handoffsDir, tasksDir]) {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    }
+    const handoffId = `${Date.now()}-manual-${agent.name}`;
+    const handoffFile = path.join(handoffsDir, `${handoffId}.yaml`);
+    const taskFile = path.join(tasksDir, `${handoffId}.md`);
+    const handoff = {
+      id: handoffId,
+      from: "orchestrator",
+      to: agent.name,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "pending",
+      completed: {
+        symbols: options.context.symbols,
+        artifacts: []
+      },
+      context: {
+        summary: options.task,
+        key_symbols: options.context.symbols.map((s) => ({ symbol: s, relevance: "task-related" })),
+        warnings: ["This is a manual handoff - execute the task file manually"],
+        suggested_approach: `Read ${taskFile} and follow the instructions`
+      }
+    };
+    fs.writeFileSync(handoffFile, yaml.dump(handoff));
+    const taskContent = this.buildTaskFile(agent, options, handoffId);
+    fs.writeFileSync(taskFile, taskContent);
+    yield {
+      type: "text",
+      content: `
+\u{1F4CB} **Manual Handoff Created**
+
+`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    yield {
+      type: "text",
+      content: `Agent: **${agent.name}**
+`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    yield {
+      type: "text",
+      content: `Task: ${options.task}
+
+`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    yield {
+      type: "text",
+      content: `**To execute manually:**
+`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    yield {
+      type: "text",
+      content: `1. Open: ${taskFile}
+`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    yield {
+      type: "text",
+      content: `2. Follow the instructions in the file
+`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    yield {
+      type: "text",
+      content: `3. Run: \`paradigm team accept ${handoffId}\` when done
+
+`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    yield {
+      type: "text",
+      content: `Or paste this into a new Claude session:
+\`\`\`
+${this.buildPrompt(agent, options)}
+\`\`\`
+`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    yield {
+      type: "done",
+      content: "Manual handoff created",
+      usage: { input: 0, output: 0, total: 0 },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  // ==========================================================================
+  // Private Methods
+  // ==========================================================================
+  buildTaskFile(agent, options, handoffId) {
+    const lines = [];
+    lines.push(`# ${agent.name.toUpperCase()} Task`);
+    lines.push("");
+    lines.push(`> Handoff ID: ${handoffId}`);
+    lines.push(`> Created: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+    lines.push("## Task");
+    lines.push("");
+    lines.push(options.task);
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+    lines.push("## Agent Role");
+    lines.push("");
+    lines.push(agent.role);
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+    lines.push("## Focus Areas");
+    lines.push("");
+    lines.push("**Read:** " + agent.focus.reads.join(", "));
+    lines.push("");
+    lines.push("**Write:** " + agent.focus.writes.join(", "));
+    lines.push("");
+    if (options.context.symbols.length > 0) {
+      lines.push("---");
+      lines.push("");
+      lines.push("## Symbols in Scope");
+      lines.push("");
+      lines.push(options.context.symbols.map((s) => `- \`${s}\``).join("\n"));
+      lines.push("");
+    }
+    if (options.context.handoffContext) {
+      lines.push("---");
+      lines.push("");
+      lines.push("## Context from Previous Agent");
+      lines.push("");
+      lines.push(options.context.handoffContext);
+      lines.push("");
+    }
+    lines.push("---");
+    lines.push("");
+    lines.push("## When Complete");
+    lines.push("");
+    lines.push("Run:");
+    lines.push("```bash");
+    lines.push(`paradigm team accept ${handoffId}`);
+    lines.push("```");
+    lines.push("");
+    return lines.join("\n");
+  }
+  buildPrompt(agent, options) {
+    const parts = [];
+    parts.push(`You are the ${agent.name.toUpperCase()} agent.`);
+    parts.push("");
+    parts.push("## Your Role");
+    parts.push(agent.role);
+    parts.push("");
+    parts.push("## Task");
+    parts.push(options.task);
+    if (options.context.symbols.length > 0) {
+      parts.push("");
+      parts.push("## Symbols");
+      parts.push(options.context.symbols.join(", "));
+    }
+    return parts.join("\n");
+  }
+};
+export {
+  ManualProvider
+};