@shahmarasy/prodo 0.1.3 → 0.1.5

package/src/agents/google/index.ts

@@ -0,0 +1,79 @@
+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>;
+
+export class GoogleAgent extends BaseAgent {
+  readonly name = "google";
+  readonly displayName = "Google Gemini";
+  readonly sdkRequired = "@google/generative-ai";
+
+  getConfig(): AgentConfig {
+    return {
+      name: this.name,
+      displayName: this.displayName,
+      sdkRequired: this.sdkRequired,
+      envVars: ["GOOGLE_API_KEY"],
+      defaultModel: "gemini-2.0-flash"
+    };
+  }
+
+  async generate(
+    prompt: string,
+    inputContext: Record<string, unknown>,
+    schemaHint: ProviderSchemaHint
+  ): Promise<GenerateResult> {
+    const apiKey = process.env.GOOGLE_API_KEY;
+    if (!apiKey) {
+      throw new UserError("GOOGLE_API_KEY is not set. Set it to use the Google Gemini agent.");
+    }
+
+    const model = process.env.PRODO_GOOGLE_MODEL ?? "gemini-2.0-flash";
+
+    const outputLanguage =
+      typeof inputContext.outputLanguage === "string" && inputContext.outputLanguage.trim()
+        ? inputContext.outputLanguage.trim()
+        : "en";
+
+    const system = buildSystemPrompt(schemaHint, outputLanguage);
+    const user = buildUserMessage(prompt, inputContext);
+
+    let GoogleGenerativeAI: new (apiKey: string) => {
+      getGenerativeModel: (config: { model: string; systemInstruction: string }) => {
+        generateContent: (content: string) => Promise<{
+          response: { text: () => string };
+        }>;
+      };
+    };
+
+    try {
+      const mod = (await dynamicImport("@google/generative-ai")) as {
+        GoogleGenerativeAI: typeof GoogleGenerativeAI;
+      };
+      GoogleGenerativeAI = mod.GoogleGenerativeAI;
+    } catch {
+      throw new UserError(
+        "Google Generative AI SDK is not installed. Run: npm install @google/generative-ai"
+      );
+    }
+
+    const client = new GoogleGenerativeAI(apiKey);
+    const generativeModel = client.getGenerativeModel({
+      model,
+      systemInstruction: system
+    });
+
+    const result = await generativeModel.generateContent(user);
+    const content = result.response.text().trim();
+
+    if (!content) {
+      throw new UserError("Google Gemini agent returned an empty response.");
+    }
+
+    return { body: content };
+  }
+}

package/src/agents/google/manifest.json

@@ -0,0 +1,7 @@
+{
+  "name": "google",
+  "displayName": "Google Gemini",
+  "sdkRequired": "@google/generative-ai",
+  "envVars": ["GOOGLE_API_KEY"],
+  "defaultModel": "gemini-2.0-flash"
+}

package/src/agents/mock/index.ts

@@ -0,0 +1,32 @@
+import { BaseAgent, type AgentConfig } from "../base";
+import { MockProvider } from "../../providers/mock-provider";
+import type { GenerateResult, ProviderSchemaHint } from "../../core/types";
+
+export class MockAgent extends BaseAgent {
+  readonly name = "mock";
+  readonly displayName = "Mock (Testing)";
+  readonly sdkRequired = null;
+
+  private readonly provider = new MockProvider();
+
+  async generate(
+    prompt: string,
+    inputContext: Record<string, unknown>,
+    schemaHint: ProviderSchemaHint
+  ): Promise<GenerateResult> {
+    return this.provider.generate(prompt, inputContext, schemaHint);
+  }
+
+  async isAvailable(): Promise<boolean> {
+    return true;
+  }
+
+  getConfig(): AgentConfig {
+    return {
+      name: this.name,
+      displayName: this.displayName,
+      sdkRequired: null,
+      envVars: []
+    };
+  }
+}

package/src/agents/mock/manifest.json

@@ -0,0 +1,7 @@
+{
+  "name": "mock",
+  "displayName": "Mock (Testing)",
+  "sdkRequired": null,
+  "envVars": [],
+  "defaultModel": null
+}

package/src/agents/openai/index.ts

@@ -0,0 +1,83 @@
+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>;
+
+export class OpenAIAgent extends BaseAgent {
+  readonly name = "openai";
+  readonly displayName = "OpenAI";
+  readonly sdkRequired = "openai";
+
+  getConfig(): AgentConfig {
+    return {
+      name: this.name,
+      displayName: this.displayName,
+      sdkRequired: this.sdkRequired,
+      envVars: ["OPENAI_API_KEY"],
+      defaultModel: "gpt-4o-mini"
+    };
+  }
+
+  async generate(
+    prompt: string,
+    inputContext: Record<string, unknown>,
+    schemaHint: ProviderSchemaHint
+  ): Promise<GenerateResult> {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      throw new UserError("OPENAI_API_KEY is not set. Set it to use the OpenAI agent.");
+    }
+
+    const model = process.env.PRODO_OPENAI_MODEL ?? "gpt-4o-mini";
+    const baseURL = process.env.PRODO_OPENAI_BASE_URL ?? undefined;
+
+    const outputLanguage =
+      typeof inputContext.outputLanguage === "string" && inputContext.outputLanguage.trim()
+        ? inputContext.outputLanguage.trim()
+        : "en";
+
+    const system = buildSystemPrompt(schemaHint, outputLanguage);
+    const user = buildUserMessage(prompt, inputContext);
+
+    let OpenAIConstructor: new (opts: { apiKey: string; baseURL?: string }) => {
+      chat: {
+        completions: {
+          create: (params: Record<string, unknown>) => Promise<{
+            choices: Array<{ message?: { content?: string } }>;
+          }>;
+        };
+      };
+    };
+
+    try {
+      const mod = (await dynamicImport("openai")) as { default: typeof OpenAIConstructor };
+      OpenAIConstructor = mod.default;
+    } catch {
+      throw new UserError(
+        "OpenAI SDK is not installed. Run: npm install openai"
+      );
+    }
+
+    const client = new OpenAIConstructor({ apiKey, baseURL });
+
+    const response = await client.chat.completions.create({
+      model,
+      messages: [
+        { role: "system", content: system },
+        { role: "user", content: user }
+      ],
+      temperature: 0.2
+    });
+
+    const content = response.choices[0]?.message?.content?.trim();
+    if (!content) {
+      throw new UserError("OpenAI agent returned an empty response.");
+    }
+
+    return { body: content };
+  }
+}

package/src/agents/openai/manifest.json

@@ -0,0 +1,7 @@
+{
+  "name": "openai",
+  "displayName": "OpenAI",
+  "sdkRequired": "openai",
+  "envVars": ["OPENAI_API_KEY"],
+  "defaultModel": "gpt-4o-mini"
+}

package/src/agents/system-prompts.ts

@@ -0,0 +1,35 @@
+import type { ProviderSchemaHint } from "../core/types";
+
+export function buildSystemPrompt(schemaHint: ProviderSchemaHint, outputLanguage: string): string {
+  const mode = schemaHint.artifactType;
+
+  if (mode === "normalize") {
+    return `You normalize messy human product briefs into strict JSON.
+Return valid JSON only, no markdown. Include confidence scores (0..1) for critical fields.
+Preserve source language and Unicode characters exactly; never transliterate Turkish letters to ASCII.`;
+  }
+
+  if (mode === "semantic_consistency") {
+    return `You detect semantic inconsistencies between paired artifacts.
+Return valid JSON only: { "issues": [{level, code, check, contract_id, file, message, suggestion}] }.`;
+  }
+
+  if (mode === "contract_relevance") {
+    return `You verify whether tagged content actually matches the referenced contract text.
+Return valid JSON only: { "relevant": boolean, "score": number, "reason": string }.`;
+  }
+
+  return `You are a product-document generator.
+Return only Markdown body content.
+Headings required:
+${schemaHint.requiredHeadings.join("\n")}
+Required contract tags:
+${schemaHint.requiredContracts.join(", ")}
+Use tags like [G1], [F2], [C1] where relevant.
+Output language: ${outputLanguage}
+Do not translate required headings.`;
+}
+
+export function buildUserMessage(prompt: string, inputContext: Record<string, unknown>): string {
+  return `${prompt}\n\nContext JSON:\n${JSON.stringify(inputContext, null, 2)}`;
+}

package/src/{agent-command-installer.ts → cli/agent-command-installer.ts}

@@ -1,164 +1,164 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import yaml from "js-yaml";
-import { UserError } from "./errors";
-import { ensureDir, fileExists } from "./utils";
-
-export const AI_ALIASES: Record<string, "codex" | "gemini-cli" | "claude-cli"> = {
-  codex: "codex",
-  gemini: "gemini-cli",
-  "gemmini-cli": "gemini-cli",
-  "gemmini": "gemini-cli",
-  "gemini-cli": "gemini-cli",
-  claude: "claude-cli",
-  "claude-cli": "claude-cli"
-};
-
-export type SupportedAi = "codex" | "gemini-cli" | "claude-cli";
-
-type AgentConfig = {
-  baseDir: string;
-  format: "markdown" | "toml" | "skill";
-  extension: string;
-  argsPlaceholder: string;
-};
-
-const AGENT_CONFIG: Record<SupportedAi, AgentConfig> = {
-  "claude-cli": {
-    baseDir: ".claude/commands",
-    format: "markdown",
-    extension: ".md",
-    argsPlaceholder: "$ARGUMENTS"
-  },
-  "gemini-cli": {
-    baseDir: ".gemini/commands",
-    format: "toml",
-    extension: ".toml",
-    argsPlaceholder: "{{args}}"
-  },
-  codex: {
-    baseDir: ".agents/skills",
-    format: "skill",
-    extension: "/SKILL.md",
-    argsPlaceholder: "$ARGUMENTS"
-  }
-};
-
-type ParsedTemplate = {
-  frontmatter: Record<string, unknown>;
-  body: string;
-};
-
-function parseFrontmatter(content: string): ParsedTemplate {
-  if (!content.startsWith("---")) return { frontmatter: {}, body: content };
-  const end = content.indexOf("\n---", 4);
-  if (end === -1) return { frontmatter: {}, body: content };
-  const fmRaw = content.slice(3, end).trim();
-  const body = content.slice(end + 4).trimStart();
-  const frontmatter = (yaml.load(fmRaw) as Record<string, unknown>) ?? {};
-  return { frontmatter, body };
-}
-
-function renderFrontmatter(frontmatter: Record<string, unknown>): string {
-  if (Object.keys(frontmatter).length === 0) return "";
-  return `---\n${yaml.dump(frontmatter)}---\n`;
-}
-
-function sanitizeFrontmatter(frontmatter: Record<string, unknown>): Record<string, unknown> {
-  const out = { ...frontmatter };
-  delete out.run;
-  delete out.scripts;
-  return out;
-}
-
-function toTomlPrompt(body: string, frontmatter: Record<string, unknown>, argsPlaceholder: string): string {
-  const description = String(frontmatter.description ?? "Prodo command");
-  const promptBody = body.replaceAll("$ARGUMENTS", argsPlaceholder);
-  return `description = "${description.replace(/"/g, '\\"')}"
-
-prompt = """
-Important execution rule:
-- This is an agent slash command, not a shell command.
-- Do NOT run \`prodo-normalize\`, \`prodo-prd\`, or \`prodo ...\` in shell.
-- Execute the workflow directly using workspace files.
-
-${promptBody}
-"""`;
-}
-
-function toSkill(name: string, body: string, frontmatter: Record<string, unknown>): string {
-  const description = String(frontmatter.description ?? "Prodo workflow command");
-  return `---
-name: ${name}
-description: ${description}
-compatibility: Requires Prodo project scaffold (.prodo)
-metadata:
-  author: prodo
-  source: .prodo/commands/${name}.md
----
-
-${body}`;
-}
-
-export function resolveAi(ai?: string): SupportedAi | undefined {
-  if (!ai) return undefined;
-  const normalized = AI_ALIASES[ai.trim().toLowerCase()];
-  if (!normalized) {
-    throw new UserError("Unsupported --ai value. Use: codex | gemini-cli | claude-cli");
-  }
-  return normalized;
-}
-
-async function loadCommandTemplateNames(commandTemplatesDir: string): Promise<string[]> {
-  if (!(await fileExists(commandTemplatesDir))) {
-    throw new UserError(`Missing command templates directory: ${commandTemplatesDir}`);
-  }
-  const entries = await fs.readdir(commandTemplatesDir, { withFileTypes: true });
-  return entries
-    .filter((entry) => entry.isFile())
-    .map((entry) => entry.name)
-    .filter((name) => name.endsWith(".md") && name.startsWith("prodo-"))
-    .map((name) => name.replace(/\.md$/, ""))
-    .sort();
-}
-
-export async function installAgentCommands(projectRoot: string, ai: SupportedAi): Promise<string[]> {
-  const cfg = AGENT_CONFIG[ai];
-  const target = path.join(projectRoot, cfg.baseDir);
-  const commandTemplatesDir = path.join(projectRoot, ".prodo", "commands");
-  const commandNames = await loadCommandTemplateNames(commandTemplatesDir);
-  await ensureDir(target);
-
-  const written: string[] = [];
-  for (const commandName of commandNames) {
-    const templatePath = path.join(commandTemplatesDir, `${commandName}.md`);
-    if (!(await fileExists(templatePath))) {
-      throw new UserError(`Missing command template: ${templatePath}`);
-    }
-    const raw = await fs.readFile(templatePath, "utf8");
-    const parsed = parseFrontmatter(raw);
-
-    if (cfg.format === "skill") {
-      const skillDir = path.join(target, commandName);
-      await ensureDir(skillDir);
-      const outPath = path.join(skillDir, "SKILL.md");
-      const content = toSkill(commandName, parsed.body.replaceAll("$ARGUMENTS", cfg.argsPlaceholder), parsed.frontmatter);
-      await fs.writeFile(outPath, content, "utf8");
-      written.push(outPath);
-      continue;
-    }
-
-    if (cfg.format === "toml") {
-      const outPath = path.join(target, `${commandName}${cfg.extension}`);
-      await fs.writeFile(outPath, toTomlPrompt(parsed.body, parsed.frontmatter, cfg.argsPlaceholder), "utf8");
-      written.push(outPath);
-      continue;
-    }
-
-    const outPath = path.join(target, `${commandName}${cfg.extension}`);
-    const replacedBody = parsed.body.replaceAll("$ARGUMENTS", cfg.argsPlaceholder);
-    await fs.writeFile(outPath, `${renderFrontmatter(sanitizeFrontmatter(parsed.frontmatter))}\n${replacedBody}`, "utf8");
-    written.push(outPath);
-  }
-  return written;
-}
+import fs from "node:fs/promises";
+import path from "node:path";
+import yaml from "js-yaml";
+import { UserError } from "../core/errors";
+import { ensureDir, fileExists } from "../core/utils";
+
+export const AI_ALIASES: Record<string, "codex" | "gemini-cli" | "claude-cli"> = {
+  codex: "codex",
+  gemini: "gemini-cli",
+  "gemmini-cli": "gemini-cli",
+  "gemmini": "gemini-cli",
+  "gemini-cli": "gemini-cli",
+  claude: "claude-cli",
+  "claude-cli": "claude-cli"
+};
+
+export type SupportedAi = "codex" | "gemini-cli" | "claude-cli";
+
+type AgentConfig = {
+  baseDir: string;
+  format: "markdown" | "toml" | "skill";
+  extension: string;
+  argsPlaceholder: string;
+};
+
+const AGENT_CONFIG: Record<SupportedAi, AgentConfig> = {
+  "claude-cli": {
+    baseDir: ".claude/commands",
+    format: "markdown",
+    extension: ".md",
+    argsPlaceholder: "$ARGUMENTS"
+  },
+  "gemini-cli": {
+    baseDir: ".gemini/commands",
+    format: "toml",
+    extension: ".toml",
+    argsPlaceholder: "{{args}}"
+  },
+  codex: {
+    baseDir: ".agents/skills",
+    format: "skill",
+    extension: "/SKILL.md",
+    argsPlaceholder: "$ARGUMENTS"
+  }
+};
+
+type ParsedTemplate = {
+  frontmatter: Record<string, unknown>;
+  body: string;
+};
+
+function parseFrontmatter(content: string): ParsedTemplate {
+  if (!content.startsWith("---")) return { frontmatter: {}, body: content };
+  const end = content.indexOf("\n---", 4);
+  if (end === -1) return { frontmatter: {}, body: content };
+  const fmRaw = content.slice(3, end).trim();
+  const body = content.slice(end + 4).trimStart();
+  const frontmatter = (yaml.load(fmRaw) as Record<string, unknown>) ?? {};
+  return { frontmatter, body };
+}
+
+function renderFrontmatter(frontmatter: Record<string, unknown>): string {
+  if (Object.keys(frontmatter).length === 0) return "";
+  return `---\n${yaml.dump(frontmatter)}---\n`;
+}
+
+function sanitizeFrontmatter(frontmatter: Record<string, unknown>): Record<string, unknown> {
+  const out = { ...frontmatter };
+  delete out.run;
+  delete out.scripts;
+  return out;
+}
+
+function toTomlPrompt(body: string, frontmatter: Record<string, unknown>, argsPlaceholder: string): string {
+  const description = String(frontmatter.description ?? "Prodo command");
+  const promptBody = body.replaceAll("$ARGUMENTS", argsPlaceholder);
+  return `description = "${description.replace(/"/g, '\\"')}"
+
+prompt = """
+Important execution rule:
+- This is an agent slash command, not a shell command.
+- Do NOT run \`prodo-normalize\`, \`prodo-prd\`, or \`prodo ...\` in shell.
+- Execute the workflow directly using workspace files.
+
+${promptBody}
+"""`;
+}
+
+function toSkill(name: string, body: string, frontmatter: Record<string, unknown>): string {
+  const description = String(frontmatter.description ?? "Prodo workflow command");
+  return `---
+name: ${name}
+description: ${description}
+compatibility: Requires Prodo project scaffold (.prodo)
+metadata:
+  author: prodo
+  source: .prodo/commands/${name}.md
+---
+
+${body}`;
+}
+
+export function resolveAi(ai?: string): SupportedAi | undefined {
+  if (!ai) return undefined;
+  const normalized = AI_ALIASES[ai.trim().toLowerCase()];
+  if (!normalized) {
+    throw new UserError("Unsupported --ai value. Use: codex | gemini-cli | claude-cli");
+  }
+  return normalized;
+}
+
+async function loadCommandTemplateNames(commandTemplatesDir: string): Promise<string[]> {
+  if (!(await fileExists(commandTemplatesDir))) {
+    throw new UserError(`Missing command templates directory: ${commandTemplatesDir}`);
+  }
+  const entries = await fs.readdir(commandTemplatesDir, { withFileTypes: true });
+  return entries
+    .filter((entry) => entry.isFile())
+    .map((entry) => entry.name)
+    .filter((name) => name.endsWith(".md") && name.startsWith("prodo-"))
+    .map((name) => name.replace(/\.md$/, ""))
+    .sort();
+}
+
+export async function installAgentCommands(projectRoot: string, ai: SupportedAi): Promise<string[]> {
+  const cfg = AGENT_CONFIG[ai];
+  const target = path.join(projectRoot, cfg.baseDir);
+  const commandTemplatesDir = path.join(projectRoot, ".prodo", "commands");
+  const commandNames = await loadCommandTemplateNames(commandTemplatesDir);
+  await ensureDir(target);
+
+  const written: string[] = [];
+  for (const commandName of commandNames) {
+    const templatePath = path.join(commandTemplatesDir, `${commandName}.md`);
+    if (!(await fileExists(templatePath))) {
+      throw new UserError(`Missing command template: ${templatePath}`);
+    }
+    const raw = await fs.readFile(templatePath, "utf8");
+    const parsed = parseFrontmatter(raw);
+
+    if (cfg.format === "skill") {
+      const skillDir = path.join(target, commandName);
+      await ensureDir(skillDir);
+      const outPath = path.join(skillDir, "SKILL.md");
+      const content = toSkill(commandName, parsed.body.replaceAll("$ARGUMENTS", cfg.argsPlaceholder), parsed.frontmatter);
+      await fs.writeFile(outPath, content, "utf8");
+      written.push(outPath);
+      continue;
+    }
+
+    if (cfg.format === "toml") {
+      const outPath = path.join(target, `${commandName}${cfg.extension}`);
+      await fs.writeFile(outPath, toTomlPrompt(parsed.body, parsed.frontmatter, cfg.argsPlaceholder), "utf8");
+      written.push(outPath);
+      continue;
+    }
+
+    const outPath = path.join(target, `${commandName}${cfg.extension}`);
+    const replacedBody = parsed.body.replaceAll("$ARGUMENTS", cfg.argsPlaceholder);
+    await fs.writeFile(outPath, `${renderFrontmatter(sanitizeFrontmatter(parsed.frontmatter))}\n${replacedBody}`, "utf8");
+    written.push(outPath);
+  }
+  return written;
+}