@shahmarasy/prodo 0.1.5 → 0.1.7

package/src/skills/generate-artifact.ts

@@ -0,0 +1,48 @@
+import { generateArtifact } from "../core/artifacts";
+import { defaultUpstreamByArtifact } from "../core/constants";
+import type { Skill, SkillManifest } from "../skill-engine/types";
+
+export function createArtifactSkill(artifactType: string, upstream?: string[]): Skill {
+  const resolvedUpstream = upstream ?? defaultUpstreamByArtifact(artifactType);
+  const depends_on = ["normalize", ...resolvedUpstream];
+
+  const manifest: SkillManifest = {
+    name: artifactType,
+    version: "2.0.0",
+    description: `Generate ${artifactType} artifact from normalized brief`,
+    category: "artifact",
+    depends_on,
+    inputs: [
+      { name: "cwd", type: "path", required: true, description: "Project working directory" },
+      { name: "normalizedBriefPath", type: "path", required: false, description: "Path to normalized brief" }
+    ],
+    outputs: [
+      { name: "artifactPath", type: "path", description: `Path to generated ${artifactType}` }
+    ],
+    tags: ["artifact", artifactType]
+  };
+
+  return {
+    manifest,
+    async execute(context, inputs) {
+      const cwd = (inputs.cwd as string) ?? context.state.cwd;
+      const normalizedBriefOverride =
+        (inputs.normalizedBriefPath as string) ?? context.state.normalizedBriefPath;
+
+      context.progress(1, 2, `Generating ${artifactType}...`);
+
+      const filePath = await generateArtifact({
+        artifactType,
+        cwd,
+        normalizedBriefOverride,
+        agent: context.agent
+      });
+
+      context.progress(2, 2, `${artifactType} generated.`);
+      context.log(`${artifactType.toUpperCase()} generated: ${filePath}`);
+      context.state.generatedArtifacts.set(artifactType, filePath);
+
+      return { artifactPath: filePath };
+    }
+  };
+}

package/src/skills/{normalize-skill.ts → normalize.ts}

@@ -1,29 +1,32 @@
 import { runNormalize } from "../core/normalize";
-import type { Skill } from "./types";
+import type { Skill } from "../skill-engine/types";
 
 export const normalizeSkill: Skill = {
   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" },
-      { name: "brief", type: "path", required: false, description: "Override path to brief.md" },
-      { name: "out", type: "path", required: false, description: "Override output path" }
+      { 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): Promise<Record<string, unknown>> {
-    const cwd = (inputs.cwd as string) ?? context.cwd;
-    const outPath = await runNormalize({
-      cwd,
-      brief: inputs.brief as string | undefined,
-      out: inputs.out as string | undefined
-    });
+  async execute(context, inputs) {
+    const cwd = (inputs.cwd as string) ?? context.state.cwd;
+    context.progress(1, 2, "Normalizing brief...");
+
+    const outPath = await runNormalize({ cwd });
+
+    context.progress(2, 2, "Brief normalized.");
     context.log(`Normalized brief written to: ${outPath}`);
+    context.state.normalizedBriefPath = outPath;
+
     return { normalizedBriefPath: outPath };
   }
 };

package/src/skills/register-core.ts

@@ -0,0 +1,27 @@
+import { listArtifactDefinitions } from "../core/artifact-registry";
+import type { SkillRegistry } from "../skill-engine/registry";
+import { createArtifactSkill } from "./generate-artifact";
+import { fixSkill } from "./fix";
+import { normalizeSkill } from "./normalize";
+import { createValidateSkill } from "./validate";
+
+export async function registerCoreSkills(
+  registry: SkillRegistry,
+  cwd: string
+): Promise<void> {
+  registry.register(normalizeSkill);
+
+  const definitions = await listArtifactDefinitions(cwd);
+  const artifactNames: string[] = [];
+
+  for (const def of definitions) {
+    const skill = createArtifactSkill(def.name, def.upstream);
+    registry.register(skill);
+    artifactNames.push(def.name);
+  }
+
+  const validateSkill = createValidateSkill(artifactNames);
+  registry.register(validateSkill);
+
+  registry.register(fixSkill);
+}

package/src/skills/validate.ts

@@ -0,0 +1,40 @@
+import { runValidate } from "../core/validate";
+import type { Skill } from "../skill-engine/types";
+
+export function createValidateSkill(artifactTypes: string[]): Skill {
+  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 as string) ?? context.state.cwd;
+      context.progress(1, 2, "Validating artifacts...");
+
+      const result = await 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/src/skills/engine.ts

@@ -1,94 +0,0 @@
-import { UserError } from "../core/errors";
-import type { Skill, SkillContext, SkillManifest } from "./types";
-
-export type SkillEngine = {
-  register(skill: Skill): void;
-  getSkill(name: string): Skill | undefined;
-  listSkills(): SkillManifest[];
-  execute(name: string, context: SkillContext, inputs: Record<string, unknown>): Promise<Record<string, unknown>>;
-};
-
-function validateInputs(skill: Skill, inputs: Record<string, unknown>): void {
-  for (const input of skill.manifest.inputs) {
-    if (input.required && !(input.name in inputs)) {
-      throw new UserError(
-        `Skill "${skill.manifest.name}" requires input "${input.name}" (${input.description})`
-      );
-    }
-  }
-}
-
-export function createSkillEngine(): SkillEngine {
-  const skills = new Map<string, Skill>();
-
-  return {
-    register(skill: Skill): void {
-      skills.set(skill.manifest.name, skill);
-    },
-
-    getSkill(name: string): Skill | undefined {
-      return skills.get(name);
-    },
-
-    listSkills(): SkillManifest[] {
-      return Array.from(skills.values()).map((s) => s.manifest);
-    },
-
-    async execute(
-      name: string,
-      context: SkillContext,
-      inputs: Record<string, unknown>
-    ): Promise<Record<string, unknown>> {
-      const skill = skills.get(name);
-      if (!skill) {
-        const available = Array.from(skills.keys()).join(", ");
-        throw new UserError(`Unknown skill: "${name}". Available: ${available}`);
-      }
-
-      validateInputs(skill, inputs);
-      return skill.execute(context, inputs);
-    }
-  };
-}
-
-let globalEngine: SkillEngine | null = null;
-
-export function getGlobalSkillEngine(): SkillEngine {
-  if (!globalEngine) {
-    globalEngine = createSkillEngine();
-    loadBuiltinSkills(globalEngine);
-  }
-  return globalEngine;
-}
-
-export function resetGlobalSkillEngine(): void {
-  globalEngine = null;
-}
-
-function loadBuiltinSkills(engine: SkillEngine): void {
-  // Lazy-load to avoid circular dependencies
-  try {
-    const { normalizeSkill } = require("./normalize-skill") as { normalizeSkill: Skill };
-    engine.register(normalizeSkill);
-  } catch { /* skill not available */ }
-
-  try {
-    const { validateSkill } = require("./validate-skill") as { validateSkill: Skill };
-    engine.register(validateSkill);
-  } catch { /* skill not available */ }
-
-  try {
-    const { fixSkill } = require("./fix-skill") as { fixSkill: Skill };
-    engine.register(fixSkill);
-  } catch { /* skill not available */ }
-
-  try {
-    const { generateArtifactSkill } = require("./generate-artifact-skill") as { generateArtifactSkill: Skill };
-    engine.register(generateArtifactSkill);
-  } catch { /* skill not available */ }
-
-  try {
-    const { generatePipelineSkill } = require("./generate-pipeline-skill") as { generatePipelineSkill: Skill };
-    engine.register(generatePipelineSkill);
-  } catch { /* skill not available */ }
-}

package/src/skills/fix-skill.ts

@@ -1,38 +0,0 @@
-import { runFix } from "../core/fix";
-import type { Skill } from "./types";
-
-export const fixSkill: Skill = {
-  manifest: {
-    name: "fix",
-    description: "Auto-regenerate artifacts that failed validation with backup and rollback",
-    category: "validation",
-    inputs: [
-      { name: "cwd", type: "path", required: true, description: "Project working directory" },
-      { name: "agent", type: "string", required: false, description: "Agent profile name" },
-      { name: "strict", type: "boolean", required: false, description: "Treat warnings as errors" },
-      { name: "dryRun", type: "boolean", required: false, description: "Preview without applying" }
-    ],
-    outputs: [
-      { name: "applied", type: "string", description: "Whether fix was applied" },
-      { name: "finalPass", type: "string", description: "Whether validation passed after fix" },
-      { name: "reportPath", type: "path", description: "Path to validation report" }
-    ]
-  },
-
-  async execute(context, inputs): Promise<Record<string, unknown>> {
-    const cwd = (inputs.cwd as string) ?? context.cwd;
-    const result = await runFix({
-      cwd,
-      agent: (inputs.agent as string) ?? context.agent,
-      strict: Boolean(inputs.strict),
-      dryRun: Boolean(inputs.dryRun),
-      log: context.log
-    });
-    return {
-      applied: result.applied,
-      finalPass: result.finalPass,
-      reportPath: result.reportPath,
-      targetCount: result.proposal.targets.length
-    };
-  }
-};

package/src/skills/generate-artifact-skill.ts

@@ -1,32 +0,0 @@
-import { generateArtifact } from "../core/artifacts";
-import type { Skill } from "./types";
-
-export const generateArtifactSkill: Skill = {
-  manifest: {
-    name: "generate-artifact",
-    description: "Generate a single artifact (PRD, workflow, wireframe, stories, techspec)",
-    category: "artifact",
-    inputs: [
-      { name: "cwd", type: "path", required: true, description: "Project working directory" },
-      { name: "artifactType", type: "string", required: true, description: "Artifact type to generate" },
-      { name: "from", type: "path", required: false, description: "Override path to normalized-brief.json" },
-      { name: "out", type: "path", required: false, description: "Override output path" }
-    ],
-    outputs: [
-      { name: "filePath", type: "path", description: "Path to generated artifact" }
-    ]
-  },
-
-  async execute(context, inputs): Promise<Record<string, unknown>> {
-    const cwd = (inputs.cwd as string) ?? context.cwd;
-    const filePath = await generateArtifact({
-      artifactType: inputs.artifactType as string,
-      cwd,
-      normalizedBriefOverride: inputs.from as string | undefined,
-      outPath: inputs.out as string | undefined,
-      agent: context.agent
-    });
-    context.log(`${(inputs.artifactType as string).toUpperCase()} generated: ${filePath}`);
-    return { filePath };
-  }
-};

package/src/skills/generate-pipeline-skill.ts

@@ -1,49 +0,0 @@
-import { listArtifactTypes } from "../core/artifact-registry";
-import { generateArtifact } from "../core/artifacts";
-import { runNormalize } from "../core/normalize";
-import { runValidate } from "../core/validate";
-import type { Skill } from "./types";
-
-export const generatePipelineSkill: Skill = {
-  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): Promise<Record<string, unknown>> {
-    const cwd = (inputs.cwd as string) ?? context.cwd;
-
-    const normalizedPath = await runNormalize({ cwd });
-    context.log(`Normalized brief: ${normalizedPath}`);
-
-    const artifactTypes = await listArtifactTypes(cwd);
-    for (const type of artifactTypes) {
-      const file = await generateArtifact({
-        artifactType: type,
-        cwd,
-        normalizedBriefOverride: normalizedPath,
-        agent: context.agent
-      });
-      context.log(`${type.toUpperCase()} generated: ${file}`);
-    }
-
-    const result = await 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/src/skills/types.ts

@@ -1,36 +0,0 @@
-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/src/skills/validate-skill.ts

@@ -1,29 +0,0 @@
-import { runValidate } from "../core/validate";
-import type { Skill } from "./types";
-
-export const validateSkill: Skill = {
-  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): Promise<Record<string, unknown>> {
-    const cwd = (inputs.cwd as string) ?? context.cwd;
-    const result = await runValidate(cwd, {
-      strict: Boolean(inputs.strict),
-      report: inputs.report as string | undefined
-    });
-    context.log(`Validation ${result.pass ? "passed" : "failed"}: ${result.reportPath}`);
-    return { pass: result.pass, reportPath: result.reportPath, issueCount: result.issues.length };
-  }
-};