@shahmarasy/prodo 0.1.4 → 0.1.6

package/src/skill-engine/validator.ts

@@ -0,0 +1,135 @@
+import { fileExists } from "../core/utils";
+import type { SkillError, SkillManifest } from "./types";
+
+function makeError(
+  skillName: string,
+  phase: SkillError["phase"],
+  message: string,
+  hints: string[] = []
+): SkillError {
+  return {
+    skillName,
+    phase,
+    message,
+    recoveryHints: hints
+  };
+}
+
+function checkType(value: unknown, expectedType: string, fieldName: string): string | null {
+  switch (expectedType) {
+    case "string":
+      if (typeof value !== "string") return `"${fieldName}" must be a string, got ${typeof value}`;
+      return null;
+
+    case "path":
+      if (typeof value !== "string") return `"${fieldName}" must be a path (string), got ${typeof value}`;
+      return null;
+
+    case "boolean":
+      if (typeof value !== "boolean") return `"${fieldName}" must be a boolean, got ${typeof value}`;
+      return null;
+
+    case "number":
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        return `"${fieldName}" must be a finite number, got ${typeof value}`;
+      }
+      return null;
+
+    case "json":
+      if (typeof value === "string") {
+        try {
+          JSON.parse(value);
+        } catch {
+          return `"${fieldName}" must be valid JSON string`;
+        }
+      }
+      return null;
+
+    default:
+      return null;
+  }
+}
+
+export function validateInputs(
+  manifest: SkillManifest,
+  inputs: Record<string, unknown>
+): SkillError | null {
+  for (const input of manifest.inputs) {
+    const value = inputs[input.name];
+
+    if (input.required && (value === undefined || value === null)) {
+      if (input.default !== undefined) continue;
+      return makeError(
+        manifest.name,
+        "input_validation",
+        `Required input "${input.name}" is missing`,
+        [`Provide "${input.name}" (${input.type}): ${input.description ?? ""}`]
+      );
+    }
+
+    if (value === undefined || value === null) continue;
+
+    const typeError = checkType(value, input.type, input.name);
+    if (typeError) {
+      return makeError(
+        manifest.name,
+        "input_validation",
+        typeError,
+        [`Expected type: ${input.type}`]
+      );
+    }
+  }
+
+  return null;
+}
+
+export async function validateInputPaths(
+  manifest: SkillManifest,
+  inputs: Record<string, unknown>
+): Promise<SkillError | null> {
+  for (const input of manifest.inputs) {
+    if (input.type !== "path") continue;
+    const value = inputs[input.name];
+    if (typeof value !== "string") continue;
+
+    if (input.required && !(await fileExists(value))) {
+      return makeError(
+        manifest.name,
+        "input_validation",
+        `Path "${input.name}" does not exist: ${value}`,
+        [`Ensure the file or directory exists: ${value}`]
+      );
+    }
+  }
+  return null;
+}
+
+export function validateOutputs(
+  manifest: SkillManifest,
+  outputs: Record<string, unknown>
+): SkillError | null {
+  for (const output of manifest.outputs) {
+    const value = outputs[output.name];
+
+    if (value === undefined || value === null) {
+      return makeError(
+        manifest.name,
+        "output_validation",
+        `Expected output "${output.name}" was not produced`,
+        [`Skill "${manifest.name}" should return "${output.name}" (${output.type})`]
+      );
+    }
+
+    const typeError = checkType(value, output.type, output.name);
+    if (typeError) {
+      return makeError(
+        manifest.name,
+        "output_validation",
+        typeError,
+        [`Skill "${manifest.name}" returned wrong type for "${output.name}"`]
+      );
+    }
+  }
+
+  return null;
+}

package/src/skills/fix.ts

@@ -0,0 +1,45 @@
+import { runFix } from "../core/fix";
+import type { Skill } from "../skill-engine/types";
+
+export const fixSkill: Skill = {
+  manifest: {
+    name: "fix",
+    version: "2.0.0",
+    description: "Auto-regenerate failing artifacts with backup, proposal, and validation",
+    category: "validation",
+    depends_on: [],
+    inputs: [
+      { name: "cwd", type: "path", required: true, description: "Project working directory" }
+    ],
+    outputs: [
+      { name: "validationResult", type: "json", description: "Final validation result after fix" }
+    ],
+    tags: ["fix", "repair", "validation"]
+  },
+
+  async execute(context, inputs) {
+    const cwd = (inputs.cwd as string) ?? context.state.cwd;
+    context.progress(1, 3, "Running fix pipeline...");
+
+    const result = await runFix({
+      cwd,
+      agent: context.agent,
+      log: context.log
+    });
+
+    context.progress(3, 3, result.finalPass ? "Fix complete." : "Fix applied, issues remain.");
+
+    context.state.validationResult = result.finalPass
+      ? { pass: true, reportPath: result.reportPath, issues: [] }
+      : undefined;
+
+    return {
+      validationResult: {
+        pass: result.finalPass,
+        reportPath: result.reportPath,
+        applied: result.applied,
+        targetCount: result.proposal.targets.length
+      }
+    };
+  }
+};

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.ts

@@ -0,0 +1,32 @@
+import { runNormalize } from "../core/normalize";
+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" }
+    ],
+    outputs: [
+      { name: "normalizedBriefPath", type: "path", description: "Path to normalized-brief.json" }
+    ],
+    tags: ["brief", "normalization"]
+  },
+
+  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
+        }
+      };
+    }
+  };
+}