forgeos 0.1.0-alpha.0

package/src/forge/review/types.ts

@@ -0,0 +1,196 @@
+import type { Diagnostic } from "../compiler/types/diagnostic.ts";
+import type { ImpactedSystems, ImpactSource } from "../impact/types.ts";
+
+export type ReviewSubcommand = "run" | "inspect" | "list" | "explain";
+export type ReviewMode = "quick" | "standard" | "strict";
+export type ReviewFailOn = "warning" | "error" | "blocking";
+export type ReviewRiskLevel = "low" | "medium" | "high" | "critical";
+export type ReviewFindingSeverity = "info" | "warning" | "error" | "blocking";
+export type ReviewFindingCategory =
+  | "runtime"
+  | "data"
+  | "policy"
+  | "secrets"
+  | "package"
+  | "workflow"
+  | "livequery"
+  | "frontend"
+  | "test"
+  | "deploy"
+  | "release"
+  | "agent";
+
+export interface ReviewCommandOptions {
+  subcommand: ReviewSubcommand;
+  workspaceRoot: string;
+  json: boolean;
+  md: boolean;
+  sarif: boolean;
+  write: boolean;
+  changed: boolean;
+  staged: boolean;
+  base?: string;
+  featureId?: string;
+  refactorId?: string;
+  upgradeId?: string;
+  releaseId?: string;
+  failOn?: ReviewFailOn;
+  mode: ReviewMode;
+  include: ReviewFindingCategory[];
+  exclude: ReviewFindingCategory[];
+  reviewId?: string;
+  ruleId?: string;
+}
+
+export type ReviewSource =
+  | { kind: "changed" }
+  | { kind: "staged" }
+  | { kind: "base"; base: string; head: string }
+  | { kind: "feature"; featureId: string }
+  | { kind: "refactor"; planId: string }
+  | { kind: "upgrade"; planId: string }
+  | { kind: "release"; releaseId: string };
+
+export interface ReviewChanged {
+  files: string[];
+  tests: string[];
+  sourceFiles: string[];
+  generated: string[];
+  packageFiles: string[];
+  deployFiles: string[];
+}
+
+export interface ReviewSummary {
+  title: string;
+  bullets: string[];
+}
+
+export interface ReviewFinding {
+  id: string;
+  severity: ReviewFindingSeverity;
+  category: ReviewFindingCategory;
+  code: string;
+  title: string;
+  message: string;
+  file?: string;
+  span?: {
+    start: number;
+    end: number;
+  };
+  affected?: {
+    commands?: string[];
+    queries?: string[];
+    liveQueries?: string[];
+    tables?: string[];
+    policies?: string[];
+    components?: string[];
+    workflows?: string[];
+    packages?: string[];
+  };
+  suggestedCommands?: string[];
+  autoRepair?: {
+    available: boolean;
+    command?: string;
+    confidence?: "low" | "medium" | "high";
+  };
+  docs?: string[];
+}
+
+export interface ReviewRisk {
+  level: ReviewRiskLevel;
+  score: number;
+  reasons: Array<{
+    code: string;
+    message: string;
+    severity: "info" | "warning" | "error";
+  }>;
+  blockers: string[];
+}
+
+export interface ReviewCheckResult {
+  name: string;
+  ok: boolean;
+  command?: string;
+  message?: string;
+}
+
+export interface ReviewChecklistItem {
+  id: string;
+  text: string;
+  required: boolean;
+  category: ReviewFindingCategory;
+}
+
+export interface ReviewReport {
+  schemaVersion: "0.1.0";
+  reviewVersion: string;
+  id: string;
+  source: ReviewSource;
+  summary: ReviewSummary;
+  risk: ReviewRisk;
+  findings: ReviewFinding[];
+  changed: ReviewChanged;
+  impacted: ImpactedSystems;
+  checks: ReviewCheckResult[];
+  recommendedCommands: string[];
+  humanChecklist: ReviewChecklistItem[];
+  agentInstructions: string[];
+  generatedArtifacts: {
+    paths: string[];
+    stale: string[];
+  };
+  createdAt?: string;
+}
+
+export interface ReviewWriteResult {
+  dir: string;
+  files: string[];
+}
+
+export interface ReviewResult {
+  ok: boolean;
+  report?: ReviewReport;
+  reports?: Array<{ id: string; dir: string }>;
+  explanation?: string;
+  writeResult?: ReviewWriteResult;
+  diagnostics: Diagnostic[];
+  exitCode: 0 | 1;
+}
+
+export interface ReviewRuleDoc {
+  id: string;
+  category: ReviewFindingCategory;
+  title: string;
+  description: string;
+  typicalFix: string[];
+  relatedCommands: string[];
+}
+
+export interface ReviewContext {
+  workspaceRoot: string;
+  source: ReviewSource;
+  impactSource: ImpactSource;
+  changed: ReviewChanged;
+  impacted: ImpactedSystems;
+  fileTexts: Map<string, string>;
+  generated: {
+    actionSubscriptions: {
+      byEvent?: Record<string, Array<{ actionName?: string }>>;
+      subscriptions?: Array<{ eventType?: string; actionName?: string }>;
+    };
+    workflowSubscriptions: {
+      byEvent?: Record<string, Array<{ workflowName?: string }>>;
+      subscriptions?: Array<{ eventType?: string; workflowName?: string }>;
+    };
+    policyRegistry: {
+      policies?: Array<{ name: string; roles?: string[] }>;
+      commandAuth?: Array<{ commandName?: string; policy?: string }>;
+      queryAuth?: Array<{ queryName?: string; policy?: string }>;
+    };
+    secretRegistry: {
+      secrets?: Array<{ name: string; envVar?: string; required?: boolean }>;
+    };
+    agentContract: unknown | null;
+  };
+  envExample: string;
+}

package/src/forge/runtime/ai/check.ts

@@ -0,0 +1,86 @@
+import { nodeFileSystem } from "../../compiler/fs/index.ts";
+import { join } from "node:path";
+import { GENERATED_DIR } from "../../compiler/emitter/constants.ts";
+import { stripDeterministicHeader } from "../../compiler/primitives/header.ts";
+import type { AiRegistry } from "../../compiler/types/ai-registry.ts";
+import type { SecretRegistry } from "../../compiler/types/secret-registry.ts";
+import type { RuntimeEnvStore } from "../secrets/types.ts";
+import { resolveProviderSecret } from "./providers.ts";
+import type { ForgeAiProvider } from "./types.ts";
+
+export function loadAiRegistry(workspaceRoot: string): AiRegistry | null {
+  const path = join(workspaceRoot, GENERATED_DIR, "aiRegistry.json");
+  if (!nodeFileSystem.exists(path)) {
+    return null;
+  }
+  const raw = stripDeterministicHeader((nodeFileSystem.readText(path) ?? ""));
+  return JSON.parse(raw) as AiRegistry;
+}
+
+export function loadAiProviders(workspaceRoot: string) {
+  const registry = loadAiRegistry(workspaceRoot);
+  return registry?.providers ?? [];
+}
+
+export function loadAiModels(workspaceRoot: string) {
+  const path = join(workspaceRoot, GENERATED_DIR, "aiModels.json");
+  if (!nodeFileSystem.exists(path)) {
+    return [];
+  }
+  const raw = stripDeterministicHeader((nodeFileSystem.readText(path) ?? ""));
+  const parsed = JSON.parse(raw) as { models: unknown[] };
+  return parsed.models;
+}
+
+export interface AiCheckResult {
+  ok: boolean;
+  providers: Array<{
+    id: ForgeAiProvider;
+    secretName: string;
+    configured: boolean;
+  }>;
+  missing: string[];
+}
+
+export function checkAiProviders(
+  store: RuntimeEnvStore,
+  registry: AiRegistry | null,
+  secretRegistry: SecretRegistry | null,
+): AiCheckResult {
+  const providers = registry?.providers ?? [];
+  const present = new Set<string>();
+  const missing: string[] = [];
+
+  const rows = providers.map((provider) => {
+    const value = store.resolve(provider.secretName);
+    const configured = value !== undefined && value.length > 0;
+    if (configured) {
+      present.add(provider.secretName);
+    } else if (
+      secretRegistry?.secrets.find((s) => s.name === provider.secretName)?.required
+    ) {
+      missing.push(provider.secretName);
+    }
+
+    return {
+      id: provider.id,
+      secretName: provider.secretName,
+      configured,
+    };
+  });
+
+  return {
+    ok: missing.length === 0,
+    providers: rows,
+    missing,
+  };
+}
+
+export function providerConfigured(
+  store: RuntimeEnvStore,
+  provider: ForgeAiProvider,
+): boolean {
+  const secret = resolveProviderSecret(provider);
+  const value = store.resolve(secret);
+  return value !== undefined && value.length > 0;
+}

package/src/forge/runtime/ai/context.ts

@@ -0,0 +1,394 @@
+import type { RuntimeContext } from "../../compiler/types/runtime.ts";
+import {
+  FORGE_AI_FORBIDDEN_CONTEXT,
+  FORGE_AI_GENERATION_FAILED,
+} from "../../compiler/diagnostics/codes.ts";
+import type { TelemetryContext } from "../telemetry/types.ts";
+import type { SecretsContext } from "../secrets/types.ts";
+import { estimateCostUsd } from "./cost-estimator.ts";
+import { createMockAiUsage, dequeueMockAiResponse } from "./mock.ts";
+import { resolveLanguageModel } from "./providers.ts";
+import { isMockAiEnabled } from "./state.ts";
+import type {
+  AiContext,
+  AiTelemetryEnvelope,
+  ForgeGenerateStructuredInput,
+  ForgeGenerateTextInput,
+  ForgeGenerateTextResult,
+  ForgeStreamTextInput,
+  ForgeStreamTextResult,
+  ForgeAiUsage,
+} from "./types.ts";
+
+const AI_ALLOWED_CONTEXTS: RuntimeContext[] = [
+  "server",
+  "action",
+  "workflow",
+  "endpoint",
+  "test",
+  "build",
+];
+
+function forgeError(code: string, message: string): never {
+  const error = new Error(message);
+  (error as Error & { code: string }).code = code;
+  throw error;
+}
+
+function mapUsage(usage: {
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+}): ForgeAiUsage {
+  const promptTokens = usage.inputTokens ?? 0;
+  const completionTokens = usage.outputTokens ?? 0;
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens: usage.totalTokens ?? promptTokens + completionTokens,
+  };
+}
+
+async function recordAiTelemetry(
+  telemetry: TelemetryContext | undefined,
+  event: string,
+  properties: Record<string, unknown>,
+): Promise<void> {
+  if (!telemetry) return;
+  await telemetry.capture(event, properties);
+}
+
+export interface CreateAiContextOptions {
+  secrets: SecretsContext;
+  telemetry?: TelemetryContext;
+  runtimeKind: RuntimeContext;
+  envelope?: AiTelemetryEnvelope;
+  mockAi?: boolean;
+}
+
+export function aiForbiddenInContext(runtimeKind: RuntimeContext): boolean {
+  return !AI_ALLOWED_CONTEXTS.includes(runtimeKind);
+}
+
+export function createAiContext(options: CreateAiContextOptions): AiContext {
+  const { secrets, telemetry, runtimeKind, envelope, mockAi } = options;
+  const useMock = isMockAiEnabled({ mockAi });
+
+  if (aiForbiddenInContext(runtimeKind)) {
+    return {
+      async generateText() {
+        forgeError(
+          FORGE_AI_FORBIDDEN_CONTEXT,
+          `ctx.ai is forbidden in '${runtimeKind}' context`,
+        );
+      },
+      async streamText() {
+        forgeError(
+          FORGE_AI_FORBIDDEN_CONTEXT,
+          `ctx.ai is forbidden in '${runtimeKind}' context`,
+        );
+      },
+      async generateStructured() {
+        forgeError(
+          FORGE_AI_FORBIDDEN_CONTEXT,
+          `ctx.ai is forbidden in '${runtimeKind}' context`,
+        );
+      },
+    };
+  }
+
+  const baseProps = () => ({
+    traceId: envelope?.traceId ?? telemetry?.traceId,
+    workflowRunId: envelope?.workflowRunId,
+    workflowStepId: envelope?.workflowStepId,
+    actionRunId: envelope?.actionRunId,
+    tenantId: envelope?.tenantId,
+    userId: envelope?.userId,
+  });
+
+  return {
+    async generateText(input: ForgeGenerateTextInput): Promise<ForgeGenerateTextResult> {
+      const startedAt = Date.now();
+      await recordAiTelemetry(telemetry, "forge.ai.generation.started", {
+        ...baseProps(),
+        provider: input.provider,
+        model: input.model,
+        purpose: input.purpose,
+        method: "generateText",
+      });
+
+      try {
+        if (useMock) {
+          const mock = dequeueMockAiResponse();
+          const usage = createMockAiUsage(mock.usage);
+          const latencyMs = Date.now() - startedAt;
+          const estimatedCostUsd = estimateCostUsd(input.provider, input.model, usage);
+
+          await recordAiTelemetry(telemetry, "forge.ai.generation.completed", {
+            ...baseProps(),
+            provider: input.provider,
+            model: input.model,
+            purpose: input.purpose,
+            latencyMs,
+            usage,
+            estimatedCostUsd,
+            status: "completed",
+            mode: "mock",
+          });
+          await recordAiTelemetry(telemetry, "forge.ai.usage", {
+            ...baseProps(),
+            provider: input.provider,
+            model: input.model,
+            usage,
+            estimatedCostUsd,
+          });
+
+          return {
+            text: mock.text,
+            provider: input.provider,
+            model: input.model,
+            purpose: input.purpose,
+            usage,
+            latencyMs,
+            estimatedCostUsd,
+          };
+        }
+
+        const languageModel = await resolveLanguageModel(
+          input.provider,
+          input.model,
+          secrets,
+        );
+        const { generateText } = await import("ai");
+        const result = await generateText({
+          model: languageModel,
+          prompt: input.prompt,
+          system: input.system,
+          temperature: input.temperature,
+          maxOutputTokens: input.maxTokens,
+        });
+
+        const usage = mapUsage(result.usage);
+        const latencyMs = Date.now() - startedAt;
+        const estimatedCostUsd = estimateCostUsd(input.provider, input.model, usage);
+
+        await recordAiTelemetry(telemetry, "forge.ai.generation.completed", {
+          ...baseProps(),
+          provider: input.provider,
+          model: input.model,
+          purpose: input.purpose,
+          latencyMs,
+          usage,
+          estimatedCostUsd,
+          status: "completed",
+        });
+        await recordAiTelemetry(telemetry, "forge.ai.usage", {
+          ...baseProps(),
+          provider: input.provider,
+          model: input.model,
+          usage,
+          estimatedCostUsd,
+        });
+
+        return {
+          text: result.text,
+          provider: input.provider,
+          model: input.model,
+          purpose: input.purpose,
+          usage,
+          latencyMs,
+          estimatedCostUsd,
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const code =
+          error instanceof Error && "code" in error
+            ? String((error as Error & { code: string }).code)
+            : FORGE_AI_GENERATION_FAILED;
+
+        await recordAiTelemetry(telemetry, "forge.ai.generation.failed", {
+          ...baseProps(),
+          provider: input.provider,
+          model: input.model,
+          purpose: input.purpose,
+          status: "failed",
+          error: message,
+          code,
+        });
+
+        if (code === FORGE_AI_GENERATION_FAILED) {
+          forgeError(FORGE_AI_GENERATION_FAILED, message);
+        }
+        throw error;
+      }
+    },
+
+    async streamText(input: ForgeStreamTextInput): Promise<ForgeStreamTextResult> {
+      const startedAt = Date.now();
+      await recordAiTelemetry(telemetry, "forge.ai.stream.started", {
+        ...baseProps(),
+        provider: input.provider,
+        model: input.model,
+        purpose: input.purpose,
+      });
+
+      if (useMock) {
+        const mock = dequeueMockAiResponse();
+        const usage = createMockAiUsage(mock.usage);
+        const latencyMs = Date.now() - startedAt;
+
+        async function* mockStream() {
+          yield mock.text;
+        }
+
+        const textPromise = Promise.resolve(mock.text).then(async (text) => {
+          await recordAiTelemetry(telemetry, "forge.ai.stream.completed", {
+            ...baseProps(),
+            provider: input.provider,
+            model: input.model,
+            purpose: input.purpose,
+            latencyMs,
+            usage,
+            status: "completed",
+            mode: "mock",
+          });
+          return text;
+        });
+
+        return {
+          textStream: mockStream(),
+          text: textPromise,
+          provider: input.provider,
+          model: input.model,
+          purpose: input.purpose,
+          usage: Promise.resolve(usage),
+          latencyMs,
+        };
+      }
+
+      const languageModel = await resolveLanguageModel(
+        input.provider,
+        input.model,
+        secrets,
+      );
+      const { streamText } = await import("ai");
+      const result = streamText({
+        model: languageModel,
+        prompt: input.prompt,
+        system: input.system,
+        temperature: input.temperature,
+        maxOutputTokens: input.maxTokens,
+      });
+
+      const latencyMs = Date.now() - startedAt;
+
+      return {
+        textStream: result.textStream,
+        text: result.text.then(async (text) => {
+          const usage = mapUsage(await result.usage);
+          await recordAiTelemetry(telemetry, "forge.ai.stream.completed", {
+            ...baseProps(),
+            provider: input.provider,
+            model: input.model,
+            purpose: input.purpose,
+            latencyMs: Date.now() - startedAt,
+            usage,
+            status: "completed",
+          });
+          return text;
+        }),
+        provider: input.provider,
+        model: input.model,
+        purpose: input.purpose,
+        usage: result.usage.then(mapUsage),
+        latencyMs,
+      };
+    },
+
+    async generateStructured<T>(input: ForgeGenerateStructuredInput<T>): Promise<T> {
+      const startedAt = Date.now();
+      await recordAiTelemetry(telemetry, "forge.ai.generation.started", {
+        ...baseProps(),
+        provider: input.provider,
+        model: input.model,
+        purpose: input.purpose,
+        method: "generateStructured",
+      });
+
+      try {
+        if (useMock) {
+          const mock = dequeueMockAiResponse();
+          let parsed: T;
+          try {
+            parsed = JSON.parse(mock.text) as T;
+          } catch {
+            parsed = { text: mock.text } as T;
+          }
+
+          const usage = createMockAiUsage(mock.usage);
+          await recordAiTelemetry(telemetry, "forge.ai.generation.completed", {
+            ...baseProps(),
+            provider: input.provider,
+            model: input.model,
+            purpose: input.purpose,
+            latencyMs: Date.now() - startedAt,
+            usage,
+            status: "completed",
+            mode: "mock",
+            method: "generateStructured",
+          });
+          return parsed;
+        }
+
+        const languageModel = await resolveLanguageModel(
+          input.provider,
+          input.model,
+          secrets,
+        );
+        const { generateText, Output } = await import("ai");
+        const result = await generateText({
+          model: languageModel,
+          prompt: input.prompt,
+          system: input.system,
+          experimental_output: Output.object({ schema: input.schema as never }),
+        });
+
+        const usage = mapUsage(result.usage);
+        await recordAiTelemetry(telemetry, "forge.ai.generation.completed", {
+          ...baseProps(),
+          provider: input.provider,
+          model: input.model,
+          purpose: input.purpose,
+          latencyMs: Date.now() - startedAt,
+          usage,
+          status: "completed",
+          method: "generateStructured",
+        });
+
+        return result.experimental_output as T;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await recordAiTelemetry(telemetry, "forge.ai.generation.failed", {
+          ...baseProps(),
+          provider: input.provider,
+          model: input.model,
+          purpose: input.purpose,
+          status: "failed",
+          error: message,
+        });
+        throw error;
+      }
+    },
+  };
+}
+
+export function createNoopAiContext(): AiContext {
+  const noop = async () => {
+    throw new Error("AI context unavailable");
+  };
+  return {
+    generateText: noop,
+    streamText: noop,
+    generateStructured: noop,
+  };
+}

package/src/forge/runtime/ai/cost-estimator.ts

@@ -0,0 +1,41 @@
+import type { ForgeAiProvider, ForgeAiUsage } from "./types.ts";
+
+export interface ModelCostRates {
+  inputCostPer1kTokensUsd: number;
+  outputCostPer1kTokensUsd: number;
+}
+
+const KNOWN_MODEL_COSTS: Record<string, ModelCostRates> = {
+  "openai:gpt-4o": { inputCostPer1kTokensUsd: 0.0025, outputCostPer1kTokensUsd: 0.01 },
+  "openai:gpt-4o-mini": {
+    inputCostPer1kTokensUsd: 0.00015,
+    outputCostPer1kTokensUsd: 0.0006,
+  },
+  "anthropic:claude-3-5-sonnet-20241022": {
+    inputCostPer1kTokensUsd: 0.003,
+    outputCostPer1kTokensUsd: 0.015,
+  },
+  "anthropic:claude-3-5-haiku-20241022": {
+    inputCostPer1kTokensUsd: 0.0008,
+    outputCostPer1kTokensUsd: 0.004,
+  },
+  "gateway:openai/gpt-4o": {
+    inputCostPer1kTokensUsd: 0.0025,
+    outputCostPer1kTokensUsd: 0.01,
+  },
+};
+
+export function estimateCostUsd(
+  provider: ForgeAiProvider,
+  model: string,
+  usage: ForgeAiUsage,
+): number | undefined {
+  const rates = KNOWN_MODEL_COSTS[`${provider}:${model}`];
+  if (!rates) {
+    return undefined;
+  }
+
+  const inputCost = (usage.promptTokens / 1000) * rates.inputCostPer1kTokensUsd;
+  const outputCost = (usage.completionTokens / 1000) * rates.outputCostPer1kTokensUsd;
+  return Math.round((inputCost + outputCost) * 1_000_000) / 1_000_000;
+}