@shahmarasy/prodo 0.1.4 → 0.1.6

package/dist/skills/generate-pipeline-skill.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePipelineSkill = void 0;
+const artifact_registry_1 = require("../core/artifact-registry");
+const artifacts_1 = require("../core/artifacts");
+const normalize_1 = require("../core/normalize");
+const validate_1 = require("../core/validate");
+exports.generatePipelineSkill = {
+    manifest: {
+        name: "generate-pipeline",
+        description: "Run end-to-end pipeline: normalize → generate all artifacts → validate",
+        category: "core",
+        inputs: [
+            { name: "cwd", type: "path", required: true, description: "Project working directory" },
+            { name: "strict", type: "boolean", required: false, description: "Treat warnings as errors" }
+        ],
+        outputs: [
+            { name: "pass", type: "string", description: "Whether validation passed" },
+            { name: "reportPath", type: "path", description: "Path to validation report" },
+            { name: "artifactCount", type: "string", description: "Number of artifacts generated" }
+        ]
+    },
+    async execute(context, inputs) {
+        const cwd = inputs.cwd ?? context.cwd;
+        const normalizedPath = await (0, normalize_1.runNormalize)({ cwd });
+        context.log(`Normalized brief: ${normalizedPath}`);
+        const artifactTypes = await (0, artifact_registry_1.listArtifactTypes)(cwd);
+        for (const type of artifactTypes) {
+            const file = await (0, artifacts_1.generateArtifact)({
+                artifactType: type,
+                cwd,
+                normalizedBriefOverride: normalizedPath,
+                agent: context.agent
+            });
+            context.log(`${type.toUpperCase()} generated: ${file}`);
+        }
+        const result = await (0, validate_1.runValidate)(cwd, { strict: Boolean(inputs.strict) });
+        context.log(`Validation ${result.pass ? "passed" : "failed"}: ${result.reportPath}`);
+        return {
+            pass: result.pass,
+            reportPath: result.reportPath,
+            artifactCount: artifactTypes.length
+        };
+    }
+};

package/dist/skills/normalize-skill.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from "./types";
+export declare const normalizeSkill: Skill;

package/dist/skills/normalize-skill.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSkill = void 0;
+const normalize_1 = require("../core/normalize");
+exports.normalizeSkill = {
+    manifest: {
+        name: "normalize",
+        description: "Normalize a product brief into structured JSON with contracts and confidence scores",
+        category: "core",
+        inputs: [
+            { name: "cwd", type: "path", required: true, description: "Project working directory" },
+            { name: "brief", type: "path", required: false, description: "Override path to brief.md" },
+            { name: "out", type: "path", required: false, description: "Override output path" }
+        ],
+        outputs: [
+            { name: "normalizedBriefPath", type: "path", description: "Path to normalized-brief.json" }
+        ]
+    },
+    async execute(context, inputs) {
+        const cwd = inputs.cwd ?? context.cwd;
+        const outPath = await (0, normalize_1.runNormalize)({
+            cwd,
+            brief: inputs.brief,
+            out: inputs.out
+        });
+        context.log(`Normalized brief written to: ${outPath}`);
+        return { normalizedBriefPath: outPath };
+    }
+};

package/dist/skills/normalize.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from "../skill-engine/types";
+export declare const normalizeSkill: Skill;

package/dist/skills/normalize.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSkill = void 0;
+const normalize_1 = require("../core/normalize");
+exports.normalizeSkill = {
+    manifest: {
+        name: "normalize",
+        version: "2.0.0",
+        description: "Normalize a product brief into structured JSON with contracts and confidence scores",
+        category: "core",
+        depends_on: [],
+        inputs: [
+            { name: "cwd", type: "path", required: true, description: "Project working directory" }
+        ],
+        outputs: [
+            { name: "normalizedBriefPath", type: "path", description: "Path to normalized-brief.json" }
+        ],
+        tags: ["brief", "normalization"]
+    },
+    async execute(context, inputs) {
+        const cwd = inputs.cwd ?? context.state.cwd;
+        context.progress(1, 2, "Normalizing brief...");
+        const outPath = await (0, normalize_1.runNormalize)({ cwd });
+        context.progress(2, 2, "Brief normalized.");
+        context.log(`Normalized brief written to: ${outPath}`);
+        context.state.normalizedBriefPath = outPath;
+        return { normalizedBriefPath: outPath };
+    }
+};

package/dist/skills/register-core.d.ts

@@ -0,0 +1,2 @@
+import type { SkillRegistry } from "../skill-engine/registry";
+export declare function registerCoreSkills(registry: SkillRegistry, cwd: string): Promise<void>;

package/dist/skills/register-core.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCoreSkills = registerCoreSkills;
+const artifact_registry_1 = require("../core/artifact-registry");
+const generate_artifact_1 = require("./generate-artifact");
+const fix_1 = require("./fix");
+const normalize_1 = require("./normalize");
+const validate_1 = require("./validate");
+async function registerCoreSkills(registry, cwd) {
+    registry.register(normalize_1.normalizeSkill);
+    const definitions = await (0, artifact_registry_1.listArtifactDefinitions)(cwd);
+    const artifactNames = [];
+    for (const def of definitions) {
+        const skill = (0, generate_artifact_1.createArtifactSkill)(def.name, def.upstream);
+        registry.register(skill);
+        artifactNames.push(def.name);
+    }
+    const validateSkill = (0, validate_1.createValidateSkill)(artifactNames);
+    registry.register(validateSkill);
+    registry.register(fix_1.fixSkill);
+}

package/dist/skills/types.d.ts

@@ -0,0 +1,28 @@
+export type SkillInput = {
+    name: string;
+    type: "path" | "string" | "boolean" | "json";
+    required: boolean;
+    description: string;
+};
+export type SkillOutput = {
+    name: string;
+    type: "path" | "string" | "json";
+    description: string;
+};
+export type SkillManifest = {
+    name: string;
+    description: string;
+    category: "core" | "artifact" | "validation" | "custom";
+    inputs: SkillInput[];
+    outputs: SkillOutput[];
+};
+export type SkillContext = {
+    cwd: string;
+    log: (message: string) => void;
+    agent?: string;
+};
+export type SkillFunction = (context: SkillContext, inputs: Record<string, unknown>) => Promise<Record<string, unknown>>;
+export type Skill = {
+    manifest: SkillManifest;
+    execute: SkillFunction;
+};

package/dist/skills/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/skills/validate-skill.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from "./types";
+export declare const validateSkill: Skill;

package/dist/skills/validate-skill.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSkill = void 0;
+const validate_1 = require("../core/validate");
+exports.validateSkill = {
+    manifest: {
+        name: "validate",
+        description: "Run cross-artifact validation and generate a report",
+        category: "validation",
+        inputs: [
+            { name: "cwd", type: "path", required: true, description: "Project working directory" },
+            { name: "strict", type: "boolean", required: false, description: "Treat warnings as errors" },
+            { name: "report", type: "path", required: false, description: "Override report output path" }
+        ],
+        outputs: [
+            { name: "pass", type: "string", description: "Whether validation passed" },
+            { name: "reportPath", type: "path", description: "Path to validation report" }
+        ]
+    },
+    async execute(context, inputs) {
+        const cwd = inputs.cwd ?? context.cwd;
+        const result = await (0, validate_1.runValidate)(cwd, {
+            strict: Boolean(inputs.strict),
+            report: inputs.report
+        });
+        context.log(`Validation ${result.pass ? "passed" : "failed"}: ${result.reportPath}`);
+        return { pass: result.pass, reportPath: result.reportPath, issueCount: result.issues.length };
+    }
+};

package/dist/skills/validate.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from "../skill-engine/types";
+export declare function createValidateSkill(artifactTypes: string[]): Skill;

package/dist/skills/validate.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createValidateSkill = createValidateSkill;
+const validate_1 = require("../core/validate");
+function createValidateSkill(artifactTypes) {
+    return {
+        manifest: {
+            name: "validate",
+            version: "2.0.0",
+            description: "Run 7-gate cross-artifact validation and generate report",
+            category: "validation",
+            depends_on: [...artifactTypes],
+            inputs: [
+                { name: "cwd", type: "path", required: true, description: "Project working directory" }
+            ],
+            outputs: [
+                { name: "validationResult", type: "json", description: "Validation result with pass/fail and issues" }
+            ],
+            tags: ["validation", "consistency"]
+        },
+        async execute(context, inputs) {
+            const cwd = inputs.cwd ?? context.state.cwd;
+            context.progress(1, 2, "Validating artifacts...");
+            const result = await (0, validate_1.runValidate)(cwd, {});
+            context.progress(2, 2, `Validation ${result.pass ? "passed" : "failed"}.`);
+            context.log(`Validation ${result.pass ? "passed" : "failed"}: ${result.reportPath}`);
+            context.state.validationResult = result;
+            return {
+                validationResult: {
+                    pass: result.pass,
+                    reportPath: result.reportPath,
+                    issueCount: result.issues.length
+                }
+            };
+        }
+    };
+}

package/package.json

@@ -1,45 +1,72 @@
-{
-  "name": "@shahmarasy/prodo",
-  "version": "0.1.4",
-  "description": "CLI-first, prompt-powered product artifact kit",
-  "main": "dist/cli.js",
-  "types": "dist/cli.d.ts",
-  "bin": {
-    "prodo": "bin/prodo.cjs"
-  },
-  "files": [
-    "bin/",
-    "dist/",
-    "templates/",
-    "presets/",
-    "src/",
-    "README.md"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "npm run build && node --test tests/*.test.cjs",
-    "verify:release": "npm run build && node scripts/verify-release-build.cjs"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "dependencies": {
-    "@clack/prompts": "^1.1.0",
-    "ajv": "^8.18.0",
-    "ajv-formats": "^3.0.1",
-    "commander": "^14.0.3",
-    "gray-matter": "^4.0.3",
-    "js-yaml": "^4.1.1"
-  },
-  "devDependencies": {
-    "@types/js-yaml": "^4.0.9",
-    "@types/node": "^25.5.0",
-    "typescript": "^5.9.3"
-  }
-}
+{
+  "name": "@shahmarasy/prodo",
+  "version": "0.1.6",
+  "description": "CLI-first, prompt-powered product artifact kit",
+  "main": "dist/cli/index.js",
+  "types": "dist/cli/index.d.ts",
+  "bin": {
+    "prodo": "bin/prodo.cjs"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "templates/",
+    "presets/",
+    "src/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "node scripts/build.cjs",
+    "test": "node scripts/test.cjs",
+    "verify:release": "node scripts/build.cjs"
+  },
+  "keywords": [
+    "product-management",
+    "prd",
+    "ai-agents",
+    "codex",
+    "claude",
+    "gemini",
+    "document-generation",
+    "cli"
+  ],
+  "author": "Shahmarasy",
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^1.1.0",
+    "ajv": "^8.18.0",
+    "ajv-formats": "^3.0.1",
+    "commander": "^14.0.3",
+    "gray-matter": "^4.0.3",
+    "js-yaml": "^4.1.1",
+    "nunjucks": "^3.2.4"
+  },
+  "peerDependencies": {
+    "openai": ">=4.0.0",
+    "@anthropic-ai/sdk": ">=0.20.0",
+    "@google/generative-ai": ">=0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "openai": {
+      "optional": true
+    },
+    "@anthropic-ai/sdk": {
+      "optional": true
+    },
+    "@google/generative-ai": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^25.5.0",
+    "@types/nunjucks": "^3.2.6",
+    "typescript": "^5.9.3"
+  }
+}

package/src/agents/agent-registry.ts

@@ -0,0 +1,93 @@
+import type { AgentPlugin } from "./base";
+import { UserError } from "../core/errors";
+import type { LLMProvider } from "../core/types";
+import { MockAgent } from "./mock";
+import { OpenAIAgent } from "./openai";
+import { AnthropicAgent } from "./anthropic";
+import { GoogleAgent } from "./google";
+
+const AGENT_ALIASES: Record<string, string> = {
+  mock: "mock",
+  openai: "openai",
+  anthropic: "anthropic",
+  claude: "anthropic",
+  google: "google",
+  gemini: "google"
+};
+
+export class AgentRegistry {
+  private agents = new Map<string, AgentPlugin>();
+
+  register(agent: AgentPlugin): void {
+    this.agents.set(agent.name, agent);
+  }
+
+  list(): AgentPlugin[] {
+    return Array.from(this.agents.values());
+  }
+
+  get(name: string): AgentPlugin | undefined {
+    const normalized = AGENT_ALIASES[name.toLowerCase().trim()] ?? name.toLowerCase().trim();
+    return this.agents.get(normalized);
+  }
+
+  async resolve(name?: string): Promise<AgentPlugin> {
+    const agentName = this.resolveAgentName(name);
+    const agent = this.get(agentName);
+
+    if (!agent) {
+      const available = this.list().map((a) => a.name).join(", ");
+      throw new UserError(
+        `Unknown agent: "${agentName}". Available agents: ${available}`
+      );
+    }
+
+    return agent;
+  }
+
+  private resolveAgentName(override?: string): string {
+    if (override) return override;
+
+    const fromEnv = process.env.PRODO_AGENT;
+    if (fromEnv) return fromEnv;
+
+    const fromLegacy = process.env.PRODO_LLM_PROVIDER;
+    if (fromLegacy) return fromLegacy;
+
+    const isTest =
+      process.env.NODE_ENV === "test" ||
+      process.env.PRODO_TEST === "1";
+    if (isTest) return "mock";
+
+    return "mock";
+  }
+
+  toProvider(agent: AgentPlugin): LLMProvider {
+    return {
+      generate: (prompt, inputContext, schemaHint) =>
+        agent.generate(prompt, inputContext, schemaHint)
+    };
+  }
+}
+
+let globalRegistry: AgentRegistry | null = null;
+
+function createDefaultRegistry(): AgentRegistry {
+  const registry = new AgentRegistry();
+  registry.register(new MockAgent());
+  registry.register(new OpenAIAgent());
+  registry.register(new AnthropicAgent());
+  registry.register(new GoogleAgent());
+  return registry;
+}
+
+export function getGlobalRegistry(): AgentRegistry {
+  if (!globalRegistry) {
+    globalRegistry = createDefaultRegistry();
+  }
+  return globalRegistry;
+}
+
+export function resetGlobalRegistry(): void {
+  globalRegistry = null;
+}

package/src/agents/anthropic/index.ts

@@ -0,0 +1,86 @@
+import { BaseAgent, type AgentConfig } from "../base";
+import { buildSystemPrompt, buildUserMessage } from "../system-prompts";
+import { UserError } from "../../core/errors";
+import type { GenerateResult, ProviderSchemaHint } from "../../core/types";
+
+const dynamicImport = new Function("specifier", "return import(specifier)") as (
+  specifier: string
+) => Promise<unknown>;
+
+type ContentBlock = { type: string; text?: string };
+
+export class AnthropicAgent extends BaseAgent {
+  readonly name = "anthropic";
+  readonly displayName = "Anthropic Claude";
+  readonly sdkRequired = "@anthropic-ai/sdk";
+
+  getConfig(): AgentConfig {
+    return {
+      name: this.name,
+      displayName: this.displayName,
+      sdkRequired: this.sdkRequired,
+      envVars: ["ANTHROPIC_API_KEY"],
+      defaultModel: "claude-sonnet-4-20250514"
+    };
+  }
+
+  async generate(
+    prompt: string,
+    inputContext: Record<string, unknown>,
+    schemaHint: ProviderSchemaHint
+  ): Promise<GenerateResult> {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      throw new UserError("ANTHROPIC_API_KEY is not set. Set it to use the Anthropic agent.");
+    }
+
+    const model = process.env.PRODO_ANTHROPIC_MODEL ?? "claude-sonnet-4-20250514";
+
+    const outputLanguage =
+      typeof inputContext.outputLanguage === "string" && inputContext.outputLanguage.trim()
+        ? inputContext.outputLanguage.trim()
+        : "en";
+
+    const system = buildSystemPrompt(schemaHint, outputLanguage);
+    const user = buildUserMessage(prompt, inputContext);
+
+    let AnthropicConstructor: new (opts: { apiKey: string }) => {
+      messages: {
+        create: (params: Record<string, unknown>) => Promise<{
+          content: ContentBlock[];
+        }>;
+      };
+    };
+
+    try {
+      const mod = (await dynamicImport("@anthropic-ai/sdk")) as {
+        default: typeof AnthropicConstructor;
+      };
+      AnthropicConstructor = mod.default;
+    } catch {
+      throw new UserError(
+        "Anthropic SDK is not installed. Run: npm install @anthropic-ai/sdk"
+      );
+    }
+
+    const client = new AnthropicConstructor({ apiKey });
+
+    const response = await client.messages.create({
+      model,
+      max_tokens: 8192,
+      system,
+      messages: [{ role: "user", content: user }]
+    });
+
+    const textBlock = response.content.find(
+      (block: ContentBlock) => block.type === "text"
+    );
+    const content = textBlock?.text?.trim() ?? "";
+
+    if (!content) {
+      throw new UserError("Anthropic agent returned an empty response.");
+    }
+
+    return { body: content };
+  }
+}

package/src/agents/anthropic/manifest.json

@@ -0,0 +1,7 @@
+{
+  "name": "anthropic",
+  "displayName": "Anthropic Claude",
+  "sdkRequired": "@anthropic-ai/sdk",
+  "envVars": ["ANTHROPIC_API_KEY"],
+  "defaultModel": "claude-sonnet-4-20250514"
+}

package/src/agents/base.ts

@@ -0,0 +1,77 @@
+import type { GenerateResult, ProviderSchemaHint } from "../core/types";
+
+export type AgentConfig = {
+  name: string;
+  displayName: string;
+  sdkRequired: string | null;
+  envVars: string[];
+  defaultModel?: string;
+};
+
+export interface AgentPlugin {
+  readonly name: string;
+  readonly displayName: string;
+  readonly sdkRequired: string | null;
+
+  generate(
+    prompt: string,
+    inputContext: Record<string, unknown>,
+    schemaHint: ProviderSchemaHint
+  ): Promise<GenerateResult>;
+
+  isAvailable(): Promise<boolean>;
+  getConfig(): AgentConfig;
+}
+
+export abstract class BaseAgent implements AgentPlugin {
+  abstract readonly name: string;
+  abstract readonly displayName: string;
+  abstract readonly sdkRequired: string | null;
+
+  abstract generate(
+    prompt: string,
+    inputContext: Record<string, unknown>,
+    schemaHint: ProviderSchemaHint
+  ): Promise<GenerateResult>;
+
+  abstract getConfig(): AgentConfig;
+
+  async isAvailable(): Promise<boolean> {
+    const config = this.getConfig();
+
+    if (config.sdkRequired) {
+      try {
+        await import(config.sdkRequired);
+      } catch {
+        return false;
+      }
+    }
+
+    for (const envVar of config.envVars) {
+      if (!process.env[envVar]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  availabilityHint(): string {
+    const config = this.getConfig();
+    const hints: string[] = [];
+
+    if (config.sdkRequired) {
+      hints.push(`SDK required: npm install ${config.sdkRequired}`);
+    }
+
+    for (const envVar of config.envVars) {
+      if (!process.env[envVar]) {
+        hints.push(`Set environment variable: ${envVar}`);
+      }
+    }
+
+    return hints.length > 0
+      ? `Agent "${config.displayName}" is not available.\n  ${hints.join("\n  ")}`
+      : `Agent "${config.displayName}" is available.`;
+  }
+}