@redstone-md/mapr 0.0.1-alpha

package/lib/config.ts

@@ -0,0 +1,385 @@
+import { cancel, isCancel, password, select, text } from "@clack/prompts";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { z } from "zod";
+
+import {
+  AiProviderClient,
+  DEFAULT_MODEL,
+  DEFAULT_MODEL_CONTEXT_SIZE,
+  DEFAULT_OPENAI_BASE_URL,
+  aiProviderConfigSchema,
+  type AiProviderConfig,
+} from "./provider";
+
+const persistedConfigSchema = z
+  .object({
+    providerType: z.enum(["openai", "openai-compatible"]).optional(),
+    providerName: z.string().min(1).optional(),
+    apiKey: z.string().min(1).optional(),
+    openAiApiKey: z.string().min(1).optional(),
+    baseURL: z.string().url().optional(),
+    model: z.string().min(1).optional(),
+    modelContextSize: z.number().int().positive().optional(),
+  })
+  .strict();
+
+const configDraftSchema = aiProviderConfigSchema.partial();
+const modelListingConfigSchema = z.object({
+  providerType: z.enum(["openai", "openai-compatible"]).default("openai"),
+  providerName: z.string().min(1).default("OpenAI"),
+  apiKey: z.string().min(1),
+  baseURL: z.string().trim().url().default(DEFAULT_OPENAI_BASE_URL),
+});
+
+type PersistedConfig = z.infer<typeof persistedConfigSchema>;
+type ConfigDraft = z.infer<typeof configDraftSchema>;
+type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
+export interface EnsureConfigOptions {
+  forceReconfigure?: boolean;
+  headless?: boolean;
+  overrides?: ConfigDraft | null;
+}
+
+interface ConfigManagerOptions {
+  homeDir?: string;
+  fetcher?: FetchLike;
+  promptConfig?: (existingConfig: ConfigDraft | null) => Promise<AiProviderConfig>;
+}
+
+function exitIfCancelled<T>(value: T): T {
+  if (isCancel(value)) {
+    cancel("Configuration cancelled.");
+    process.exit(0);
+  }
+
+  return value;
+}
+
+function mergeConfigDrafts(baseConfig: ConfigDraft | null, overrides: ConfigDraft | null): ConfigDraft | null {
+  if (!baseConfig && !overrides) {
+    return null;
+  }
+
+  const merged: ConfigDraft = {
+    ...(baseConfig ?? {}),
+    ...(overrides ?? {}),
+  };
+
+  return configDraftSchema.parse(merged);
+}
+
+function normalizePersistedConfig(config: PersistedConfig | null): ConfigDraft | null {
+  if (!config) {
+    return null;
+  }
+
+  return configDraftSchema.parse({
+    providerType: config.providerType ?? "openai",
+    providerName: config.providerName ?? "OpenAI",
+    apiKey: config.apiKey ?? config.openAiApiKey,
+    baseURL: config.baseURL ?? DEFAULT_OPENAI_BASE_URL,
+    model: config.model ?? DEFAULT_MODEL,
+    modelContextSize: config.modelContextSize ?? DEFAULT_MODEL_CONTEXT_SIZE,
+  });
+}
+
+async function promptForModel(
+  config: Omit<AiProviderConfig, "model" | "modelContextSize">,
+  fetcher: FetchLike,
+  initialModel?: string,
+): Promise<string> {
+  const providerClient = new AiProviderClient({
+    ...config,
+    model: initialModel ?? DEFAULT_MODEL,
+    modelContextSize: DEFAULT_MODEL_CONTEXT_SIZE,
+  });
+
+  try {
+    const models = await providerClient.fetchModels(fetcher);
+    if (models.length === 0) {
+      throw new Error("No models returned by the provider.");
+    }
+
+    let currentSearch = "";
+
+    while (true) {
+      const searchTerm = String(
+        exitIfCancelled(
+          await text({
+            message: "Search models",
+            placeholder: currentSearch || "gpt, llama, qwen, coder",
+            initialValue: currentSearch,
+          }),
+        ),
+      ).trim();
+
+      currentSearch = searchTerm;
+      const filteredModels = models.filter((model) =>
+        searchTerm.length === 0 ? true : model.toLowerCase().includes(searchTerm.toLowerCase()),
+      );
+      const visibleModels = filteredModels.slice(0, 15);
+
+      const selectedModel = exitIfCancelled(
+        await select({
+          message: "Select model",
+          options: [
+            ...visibleModels.map((model) => ({ value: model, label: model })),
+            { value: "__search_again__", label: "Search again" },
+            { value: "__manual__", label: "Enter model manually" },
+          ],
+        }),
+      );
+
+      if (selectedModel === "__search_again__") {
+        continue;
+      }
+
+      if (selectedModel === "__manual__") {
+        break;
+      }
+
+      return z.string().min(1).parse(selectedModel);
+    }
+  } catch {
+    return z
+      .string()
+      .trim()
+      .min(1, "Model is required.")
+      .parse(
+        exitIfCancelled(
+          await text({
+            message: "Enter model ID manually",
+            placeholder: DEFAULT_MODEL,
+            initialValue: initialModel ?? DEFAULT_MODEL,
+            validate(value) {
+              const parsed = z.string().trim().min(1).safeParse(value);
+              return parsed.success ? undefined : "Model is required.";
+            },
+          }),
+        ),
+      );
+  }
+
+  return z
+    .string()
+    .trim()
+    .min(1, "Model is required.")
+    .parse(
+      exitIfCancelled(
+        await text({
+          message: "Enter model ID manually",
+          placeholder: DEFAULT_MODEL,
+          initialValue: initialModel ?? DEFAULT_MODEL,
+          validate(value) {
+            const parsed = z.string().trim().min(1).safeParse(value);
+            return parsed.success ? undefined : "Model is required.";
+          },
+        }),
+      ),
+    );
+}
+
+async function promptForContextSize(defaultValue: number): Promise<number> {
+  const rawValue = exitIfCancelled(
+    await text({
+      message: "Model context size in tokens",
+      placeholder: String(DEFAULT_MODEL_CONTEXT_SIZE),
+      initialValue: String(defaultValue),
+      validate(value) {
+        const parsed = z.coerce.number().int().positive().safeParse(value);
+        return parsed.success ? undefined : "Context size must be a positive integer.";
+      },
+    }),
+  );
+
+  return z.coerce.number().int().positive().parse(rawValue);
+}
+
+export type AppConfig = AiProviderConfig;
+export { DEFAULT_MODEL, DEFAULT_MODEL_CONTEXT_SIZE } from "./provider";
+
+export class ConfigManager {
+  private readonly homeDirectory: string;
+  private readonly fetcher: FetchLike;
+  private readonly promptConfigOverride: ((existingConfig: ConfigDraft | null) => Promise<AiProviderConfig>) | undefined;
+
+  public constructor(options: ConfigManagerOptions = {}) {
+    this.homeDirectory = options.homeDir ?? homedir();
+    this.fetcher = options.fetcher ?? fetch;
+    this.promptConfigOverride = options.promptConfig;
+  }
+
+  public getConfigDir(): string {
+    return join(this.homeDirectory, ".mapr");
+  }
+
+  public getConfigPath(): string {
+    return join(this.getConfigDir(), "config.json");
+  }
+
+  public async readConfig(): Promise<ConfigDraft | null> {
+    try {
+      const raw = await readFile(this.getConfigPath(), "utf8");
+      const parsed = persistedConfigSchema.parse(JSON.parse(raw) as unknown);
+      return normalizePersistedConfig(parsed);
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        return null;
+      }
+
+      if (error instanceof z.ZodError) {
+        throw new Error(`Invalid config file at ${this.getConfigPath()}: ${error.issues[0]?.message ?? "schema error"}`);
+      }
+
+      if (error instanceof SyntaxError) {
+        throw new Error(`Config file at ${this.getConfigPath()} is not valid JSON.`);
+      }
+
+      throw error;
+    }
+  }
+
+  public async saveConfig(config: AppConfig): Promise<void> {
+    const validatedConfig = aiProviderConfigSchema.parse(config);
+    await mkdir(this.getConfigDir(), { recursive: true });
+    await writeFile(this.getConfigPath(), `${JSON.stringify(validatedConfig, null, 2)}\n`, {
+      encoding: "utf8",
+      mode: 0o600,
+    });
+  }
+
+  public async ensureConfig(options: EnsureConfigOptions = {}): Promise<AppConfig> {
+    const mergedDraft = await this.resolveConfigDraft(options.overrides ?? null);
+
+    if (options.headless) {
+      try {
+        const resolvedConfig = aiProviderConfigSchema.parse(mergedDraft);
+        await this.saveConfig(resolvedConfig);
+        return resolvedConfig;
+      } catch (error) {
+        if (error instanceof z.ZodError) {
+          throw new Error(`Headless mode requires a complete provider config: ${error.issues[0]?.message ?? "missing field"}`);
+        }
+
+        throw error;
+      }
+    }
+
+    if (mergedDraft && !options.forceReconfigure) {
+      const parsedConfig = aiProviderConfigSchema.safeParse(mergedDraft);
+      if (parsedConfig.success) {
+        await this.saveConfig(parsedConfig.data);
+        return parsedConfig.data;
+      }
+    }
+
+    const config = this.promptConfigOverride
+      ? aiProviderConfigSchema.parse(await this.promptConfigOverride(mergedDraft))
+      : await this.promptForConfig(mergedDraft);
+
+    await this.saveConfig(config);
+    return config;
+  }
+
+  public async listModels(config: ConfigDraft | null): Promise<string[]> {
+    const resolvedConfig = modelListingConfigSchema.parse(config);
+    const providerClient = new AiProviderClient({
+      ...resolvedConfig,
+      model: DEFAULT_MODEL,
+      modelContextSize: DEFAULT_MODEL_CONTEXT_SIZE,
+    });
+    return providerClient.fetchModels(this.fetcher);
+  }
+
+  public async resolveConfigDraft(overrides: ConfigDraft | null): Promise<ConfigDraft | null> {
+    const existingConfig = await this.readConfig();
+    return mergeConfigDrafts(existingConfig, overrides);
+  }
+
+  private async promptForConfig(existingConfig: ConfigDraft | null): Promise<AppConfig> {
+    const providerType = exitIfCancelled(
+      await select({
+        message: "Choose AI provider",
+        initialValue: existingConfig?.providerType ?? "openai",
+        options: [
+          { value: "openai", label: "OpenAI" },
+          { value: "openai-compatible", label: "OpenAI-compatible server" },
+        ],
+      }),
+    ) as AiProviderConfig["providerType"];
+
+    const providerName =
+      providerType === "openai"
+        ? "OpenAI"
+        : z.string().trim().min(1).parse(
+            exitIfCancelled(
+              await text({
+                message: "Provider display name",
+                placeholder: "Local vLLM, LM Studio, Ollama gateway",
+                initialValue: existingConfig?.providerName && existingConfig.providerType === "openai-compatible"
+                  ? existingConfig.providerName
+                  : "",
+                validate(value) {
+                  const parsed = z.string().trim().min(1).safeParse(value);
+                  return parsed.success ? undefined : "Provider name is required.";
+                },
+              }),
+            ),
+          );
+
+    const baseURL = z.string().trim().url().parse(
+      exitIfCancelled(
+        await text({
+          message: providerType === "openai" ? "OpenAI base URL" : "OpenAI-compatible base URL",
+          placeholder: DEFAULT_OPENAI_BASE_URL,
+          initialValue:
+            existingConfig?.baseURL && existingConfig.providerType === providerType
+              ? existingConfig.baseURL
+              : DEFAULT_OPENAI_BASE_URL,
+          validate(value) {
+            const parsed = z.string().trim().url().safeParse(value);
+            return parsed.success ? undefined : "Base URL must be a valid URL.";
+          },
+        }),
+      ),
+    );
+
+    const apiKey = z.string().trim().min(1).parse(
+      exitIfCancelled(
+        await password({
+          message: providerType === "openai" ? "Enter your OpenAI API key" : "Enter your provider API key",
+          mask: "*",
+          validate(value) {
+            const parsed = z.string().trim().min(1).safeParse(value);
+            return parsed.success ? undefined : "API key is required.";
+          },
+        }),
+      ),
+    );
+
+    const model = await promptForModel(
+      {
+        providerType,
+        providerName,
+        baseURL,
+        apiKey,
+      },
+      this.fetcher,
+      existingConfig?.providerType === providerType ? existingConfig.model : undefined,
+    );
+
+    const modelContextSize = await promptForContextSize(existingConfig?.modelContextSize ?? DEFAULT_MODEL_CONTEXT_SIZE);
+
+    return aiProviderConfigSchema.parse({
+      providerType,
+      providerName,
+      baseURL,
+      apiKey,
+      model,
+      modelContextSize,
+    });
+  }
+}

package/lib/formatter.ts

@@ -0,0 +1,109 @@
+import * as prettier from "prettier";
+import { z } from "zod";
+
+import { artifactTypeSchema, type DiscoveredArtifact } from "./artifacts";
+
+const formattedArtifactSchema = z.object({
+  url: z.string().url(),
+  type: artifactTypeSchema,
+  content: z.string(),
+  formattedContent: z.string(),
+  sizeBytes: z.number().int().nonnegative(),
+  discoveredFrom: z.string().min(1),
+  formattingSkipped: z.boolean(),
+  formattingNote: z.string().optional(),
+});
+
+export type FormattedArtifact = z.infer<typeof formattedArtifactSchema>;
+
+function resolvePrettierParser(artifactType: FormattedArtifact["type"]): "babel" | "babel-ts" | "html" | "css" | "json" | null {
+  switch (artifactType) {
+    case "html":
+      return "html";
+    case "stylesheet":
+      return "css";
+    case "manifest":
+    case "json":
+      return "json";
+    case "script":
+    case "service-worker":
+    case "worker":
+      return "babel";
+    case "wasm":
+      return null;
+  }
+}
+
+export class BundleFormatter {
+  public async formatArtifacts(artifacts: DiscoveredArtifact[]): Promise<FormattedArtifact[]> {
+    return Promise.all(artifacts.map((artifact) => this.formatArtifact(artifact)));
+  }
+
+  public async formatArtifact(artifact: DiscoveredArtifact): Promise<FormattedArtifact> {
+    const validatedArtifact = z
+      .object({
+        url: z.string().url(),
+        type: artifactTypeSchema,
+        content: z.string(),
+        sizeBytes: z.number().int().nonnegative(),
+        discoveredFrom: z.string().min(1),
+      })
+      .parse(artifact);
+
+    const parser = resolvePrettierParser(validatedArtifact.type);
+    if (!parser) {
+      return formattedArtifactSchema.parse({
+        ...validatedArtifact,
+        formattedContent: validatedArtifact.content,
+        formattingSkipped: false,
+        formattingNote: "Binary artifact summarized without additional formatting.",
+      });
+    }
+
+    try {
+      const formattedContent = await prettier.format(validatedArtifact.content, {
+        parser,
+        printWidth: 100,
+        tabWidth: 2,
+      });
+
+      return formattedArtifactSchema.parse({
+        ...validatedArtifact,
+        formattedContent,
+        formattingSkipped: false,
+      });
+    } catch (primaryError) {
+      if (parser === "babel") {
+        try {
+          const formattedContent = await prettier.format(validatedArtifact.content, {
+            parser: "babel-ts",
+            printWidth: 100,
+            tabWidth: 2,
+          });
+
+          return formattedArtifactSchema.parse({
+            ...validatedArtifact,
+            formattedContent,
+            formattingSkipped: false,
+          });
+        } catch {
+          const message = primaryError instanceof Error ? primaryError.message : "formatter error";
+          return formattedArtifactSchema.parse({
+            ...validatedArtifact,
+            formattedContent: validatedArtifact.content,
+            formattingSkipped: true,
+            formattingNote: `Formatting failed and raw content was preserved: ${message}`,
+          });
+        }
+      }
+
+      const message = primaryError instanceof Error ? primaryError.message : "formatter error";
+      return formattedArtifactSchema.parse({
+        ...validatedArtifact,
+        formattedContent: validatedArtifact.content,
+        formattingSkipped: true,
+        formattingNote: `Formatting failed and raw content was preserved: ${message}`,
+      });
+    }
+  }
+}

package/lib/local-rag.ts

@@ -0,0 +1,104 @@
+import { z } from "zod";
+
+import type { FormattedArtifact } from "./formatter";
+
+const ragOptionsSchema = z.object({
+  segmentBytes: z.number().int().positive().default(16 * 1024),
+  maxResults: z.number().int().positive().default(3),
+});
+
+const tokenPattern = /[a-zA-Z0-9_$.-]{2,}/g;
+
+interface RagSegment {
+  artifactUrl: string;
+  segmentIndex: number;
+  content: string;
+  tokenWeights: Map<string, number>;
+}
+
+function tokenize(source: string): string[] {
+  return (source.toLowerCase().match(tokenPattern) ?? []).slice(0, 4000);
+}
+
+function toTokenWeights(source: string): Map<string, number> {
+  const weights = new Map<string, number>();
+
+  for (const token of tokenize(source)) {
+    weights.set(token, (weights.get(token) ?? 0) + 1);
+  }
+
+  return weights;
+}
+
+function segmentContent(source: string, segmentBytes: number): string[] {
+  if (source.length === 0) {
+    return [];
+  }
+
+  const segments: string[] = [];
+  let cursor = 0;
+
+  while (cursor < source.length) {
+    const nextCursor = Math.min(source.length, cursor + segmentBytes);
+    segments.push(source.slice(cursor, nextCursor));
+    cursor = nextCursor;
+  }
+
+  return segments;
+}
+
+function scoreSegment(queryWeights: Map<string, number>, segmentWeights: Map<string, number>): number {
+  let score = 0;
+
+  for (const [token, queryWeight] of queryWeights.entries()) {
+    score += queryWeight * (segmentWeights.get(token) ?? 0);
+  }
+
+  return score;
+}
+
+export interface LocalRagQuery {
+  artifactUrl: string;
+  query: string;
+  excludeContent?: string;
+}
+
+export class LocalArtifactRag {
+  private readonly options: z.infer<typeof ragOptionsSchema>;
+  private readonly segmentsByArtifact = new Map<string, RagSegment[]>();
+
+  public constructor(artifacts: FormattedArtifact[], options: z.input<typeof ragOptionsSchema> = {}) {
+    this.options = ragOptionsSchema.parse(options);
+
+    for (const artifact of artifacts) {
+      const segments = segmentContent(artifact.formattedContent || artifact.content, this.options.segmentBytes).map(
+        (content, segmentIndex) => ({
+          artifactUrl: artifact.url,
+          segmentIndex,
+          content,
+          tokenWeights: toTokenWeights(content),
+        }),
+      );
+
+      this.segmentsByArtifact.set(artifact.url, segments);
+    }
+  }
+
+  public query(input: LocalRagQuery): string[] {
+    const queryWeights = toTokenWeights(input.query);
+    const segments = this.segmentsByArtifact.get(input.artifactUrl) ?? [];
+    const excludeSnippet = input.excludeContent?.slice(0, 256);
+
+    return segments
+      .filter((segment) => !excludeSnippet || !segment.content.includes(excludeSnippet))
+      .map((segment) => ({
+        score: scoreSegment(queryWeights, segment.tokenWeights),
+        content: segment.content,
+        segmentIndex: segment.segmentIndex,
+      }))
+      .filter((entry) => entry.score > 0)
+      .sort((left, right) => right.score - left.score || left.segmentIndex - right.segmentIndex)
+      .slice(0, this.options.maxResults)
+      .map((entry) => entry.content);
+  }
+}

package/lib/progress.ts

@@ -0,0 +1,10 @@
+import pc from "picocolors";
+
+export function renderProgressBar(completed: number, total: number, width = 24): string {
+  const safeTotal = Math.max(1, total);
+  const ratio = Math.min(1, Math.max(0, completed / safeTotal));
+  const filled = Math.round(ratio * width);
+  const empty = Math.max(0, width - filled);
+
+  return `${pc.cyan("[" + "=".repeat(filled) + "-".repeat(empty) + "]")} ${Math.round(ratio * 100)}%`;
+}

package/lib/provider.ts

@@ -0,0 +1,85 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { z } from "zod";
+
+export const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+export const DEFAULT_MODEL = "gpt-4.1-mini";
+export const DEFAULT_MODEL_CONTEXT_SIZE = 128000;
+
+export const providerTypeSchema = z.enum(["openai", "openai-compatible"]);
+
+export const aiProviderConfigSchema = z.object({
+  providerType: providerTypeSchema.default("openai"),
+  providerName: z.string().min(1).default("OpenAI"),
+  apiKey: z.string().min(1, "API key is required."),
+  baseURL: z.string().trim().url("Base URL must be a valid URL.").default(DEFAULT_OPENAI_BASE_URL),
+  model: z.string().min(1).default(DEFAULT_MODEL),
+  modelContextSize: z.number().int().positive().default(DEFAULT_MODEL_CONTEXT_SIZE),
+});
+
+const modelListResponseSchema = z.object({
+  data: z.array(
+    z.object({
+      id: z.string().min(1),
+      created: z.number().optional(),
+      owned_by: z.string().optional(),
+    }),
+  ),
+});
+
+export type AiProviderConfig = z.infer<typeof aiProviderConfigSchema>;
+
+type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
+function normalizeBaseUrl(baseURL: string): string {
+  return new URL(baseURL).toString().replace(/\/$/, "");
+}
+
+export class AiProviderClient {
+  private readonly config: AiProviderConfig;
+
+  public constructor(config: AiProviderConfig) {
+    this.config = aiProviderConfigSchema.parse(config);
+  }
+
+  public getConfig(): AiProviderConfig {
+    return this.config;
+  }
+
+  public getModel(modelId = this.config.model) {
+    if (this.config.providerType === "openai-compatible") {
+      const provider = createOpenAICompatible({
+        name: this.config.providerName,
+        apiKey: this.config.apiKey,
+        baseURL: this.config.baseURL,
+      });
+
+      return provider(modelId);
+    }
+
+    const provider = createOpenAI({
+      apiKey: this.config.apiKey,
+      baseURL: this.config.baseURL,
+    });
+
+    return provider(modelId);
+  }
+
+  public async fetchModels(fetcher: FetchLike = fetch): Promise<string[]> {
+    const endpoint = new URL("models", `${normalizeBaseUrl(this.config.baseURL)}/`).toString();
+    const response = await fetcher(endpoint, {
+      headers: {
+        Authorization: `Bearer ${this.config.apiKey}`,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Model discovery failed: ${response.status} ${response.statusText}`);
+    }
+
+    const payload = modelListResponseSchema.parse((await response.json()) as unknown);
+    return [...new Set(payload.data.map((entry) => entry.id).filter(Boolean))].sort((left, right) =>
+      left.localeCompare(right),
+    );
+  }
+}