@shahmarasy/prodo 0.1.0

package/src/agents.ts

@@ -0,0 +1,56 @@
+import { UserError } from "./errors";
+
+export const AGENT_IDS = ["codex", "gemini-cli", "claude-cli"] as const;
+export type AgentId = (typeof AGENT_IDS)[number];
+
+export function isSupportedAgent(agent?: string): agent is AgentId {
+  if (!agent) return false;
+  return AGENT_IDS.includes(agent as AgentId);
+}
+
+export function resolveAgent(agent?: string): AgentId | undefined {
+  if (!agent) return undefined;
+  if (!isSupportedAgent(agent)) {
+    throw new UserError(`Unsupported agent: ${agent}. Supported: ${AGENT_IDS.join(", ")}`);
+  }
+  return agent;
+}
+
+export type CommandSetItem = {
+  command: string;
+  purpose: string;
+};
+
+export type AgentCommandSet = {
+  agent: string;
+  description?: string;
+  recommended_sequence?: CommandSetItem[];
+  artifact_shortcuts?: Record<string, string>;
+};
+
+export async function loadAgentCommandSet(_cwd: string, agent: AgentId): Promise<AgentCommandSet> {
+  const prefix = `prodo-${agent}`;
+  return {
+    agent,
+    description: "Agent-specific command set for Prodo artifact pipeline.",
+    recommended_sequence: [
+      { command: "prodo init . --ai <agent> --lang <en|tr>", purpose: "Initialize Prodo scaffold and agent commands." },
+      { command: `${prefix} normalize`, purpose: "Normalize start brief into normalized brief JSON." },
+      { command: `${prefix} prd`, purpose: "Generate PRD artifact." },
+      { command: `${prefix} workflow`, purpose: "Generate workflow artifact." },
+      { command: `${prefix} wireframe`, purpose: "Generate wireframe artifact." },
+      { command: `${prefix} stories`, purpose: "Generate stories artifact." },
+      { command: `${prefix} techspec`, purpose: "Generate techspec artifact." },
+      { command: `${prefix} validate`, purpose: "Run validation report." }
+    ],
+    artifact_shortcuts: {
+      normalize: `${prefix} normalize`,
+      prd: `${prefix} prd`,
+      workflow: `${prefix} workflow`,
+      wireframe: `${prefix} wireframe`,
+      stories: `${prefix} stories`,
+      techspec: `${prefix} techspec`,
+      validate: `${prefix} validate`
+    }
+  };
+}

package/src/artifact-registry.ts

@@ -0,0 +1,69 @@
+import {
+  defaultOutputDir,
+  defaultRequiredContractsByArtifact,
+  defaultRequiredHeadings,
+  defaultUpstreamByArtifact
+} from "./constants";
+import { readProjectConfig } from "./project-config";
+import { ARTIFACT_TYPES } from "./types";
+import type { ArtifactType, ContractCoverage } from "./types";
+
+export type ArtifactDefinition = {
+  name: ArtifactType;
+  output_dir: string;
+  required_headings: string[];
+  upstream: ArtifactType[];
+  required_contracts: Array<keyof ContractCoverage>;
+};
+
+function normalizeName(name: string): string {
+  return name.trim().toLowerCase().replace(/[^a-z0-9_-]/g, "-");
+}
+
+function toDefinition(partial: {
+  name: string;
+  output_dir?: string;
+  required_headings?: string[];
+  upstream?: string[];
+  required_contracts?: Array<keyof ContractCoverage>;
+}): ArtifactDefinition {
+  const name = normalizeName(partial.name);
+  const outputDir = partial.output_dir?.trim() || defaultOutputDir(name);
+  const requiredHeadings = partial.required_headings?.length ? partial.required_headings : defaultRequiredHeadings(name);
+  const upstream = (partial.upstream?.length ? partial.upstream : defaultUpstreamByArtifact(name)).map(normalizeName);
+  const requiredContracts = partial.required_contracts?.length
+    ? partial.required_contracts
+    : defaultRequiredContractsByArtifact(name);
+  return {
+    name,
+    output_dir: outputDir,
+    required_headings: requiredHeadings,
+    upstream,
+    required_contracts: requiredContracts
+  };
+}
+
+export async function listArtifactDefinitions(cwd: string): Promise<ArtifactDefinition[]> {
+  const config = await readProjectConfig(cwd);
+  const base = ARTIFACT_TYPES.map((name) => toDefinition({ name }));
+  const byName = new Map<string, ArtifactDefinition>(base.map((item) => [item.name, item]));
+  for (const extra of config.artifacts ?? []) {
+    const merged = toDefinition(extra);
+    byName.set(merged.name, merged);
+  }
+  return Array.from(byName.values());
+}
+
+export async function listArtifactTypes(cwd: string): Promise<ArtifactType[]> {
+  const defs = await listArtifactDefinitions(cwd);
+  return defs.map((item) => item.name);
+}
+
+export async function getArtifactDefinition(cwd: string, artifactType: string): Promise<ArtifactDefinition> {
+  const normalized = normalizeName(artifactType);
+  const defs = await listArtifactDefinitions(cwd);
+  const found = defs.find((item) => item.name === normalized);
+  if (found) return found;
+  return toDefinition({ name: normalized });
+}
+