@dobby.ai/dobby 0.1.0 → 0.1.2

package/src/cli/shared/init-catalog.ts

@@ -1,189 +0,0 @@
-import type { RawBindingConfig, RawRouteProfile } from "./config-types.js";
-import {
-  DEFAULT_DISCORD_CONNECTOR_INSTANCE_ID,
-  DISCORD_CONNECTOR_CONTRIBUTION_ID,
-} from "./discord-config.js";
-
-export type InitProviderChoiceId = "provider.pi" | "provider.claude-cli";
-export type InitConnectorChoiceId = "connector.discord";
-
-interface ProviderCatalogEntry {
-  id: InitProviderChoiceId;
-  label: string;
-  extensionPackage: string;
-  instanceId: string;
-  contributionId: string;
-  config: Record<string, unknown>;
-}
-
-interface ConnectorCatalogEntry {
-  id: InitConnectorChoiceId;
-  label: string;
-  extensionPackage: string;
-  instanceId: string;
-  contributionId: string;
-}
-
-export interface InitSelectionContext {
-  routeId: string;
-  projectRoot: string;
-  allowAllMessages: boolean;
-  botName: string;
-  botToken: string;
-  channelId: string;
-  routeProviderChoiceId: InitProviderChoiceId;
-}
-
-export interface InitSelectionResult {
-  providerChoiceIds: InitProviderChoiceId[];
-  routeProviderChoiceId: InitProviderChoiceId;
-  providerChoiceId: InitProviderChoiceId;
-  connectorChoiceId: InitConnectorChoiceId;
-  extensionPackages: string[];
-  providerInstances: Array<{
-    choiceId: InitProviderChoiceId;
-    instanceId: string;
-    contributionId: string;
-    config: Record<string, unknown>;
-  }>;
-  providerInstanceId: string;
-  providerContributionId: string;
-  providerConfig: Record<string, unknown>;
-  connectorInstanceId: string;
-  connectorContributionId: string;
-  connectorConfig: Record<string, unknown>;
-  routeProfile: RawRouteProfile;
-  bindingId: string;
-  bindingConfig: RawBindingConfig;
-}
-
-const PROVIDER_CATALOG: Record<InitProviderChoiceId, ProviderCatalogEntry> = {
-  "provider.pi": {
-    id: "provider.pi",
-    label: "Pi provider",
-    extensionPackage: "@dobby.ai/provider-pi",
-    instanceId: "pi.main",
-    contributionId: "provider.pi",
-    config: {
-      provider: "custom-openai",
-      model: "example-model",
-      thinkingLevel: "off",
-      modelsFile: "./models.custom.json",
-    },
-  },
-  "provider.claude-cli": {
-    id: "provider.claude-cli",
-    label: "Claude CLI provider",
-    extensionPackage: "@dobby.ai/provider-claude-cli",
-    instanceId: "claude-cli.main",
-    contributionId: "provider.claude-cli",
-    config: {
-      model: "claude-sonnet-4-5",
-      maxTurns: 20,
-      command: "claude",
-      commandArgs: [],
-      authMode: "auto",
-      permissionMode: "bypassPermissions",
-      streamVerbose: true,
-    },
-  },
-};
-
-const CONNECTOR_CATALOG: Record<InitConnectorChoiceId, ConnectorCatalogEntry> = {
-  "connector.discord": {
-    id: "connector.discord",
-    label: "Discord connector",
-    extensionPackage: "@dobby.ai/connector-discord",
-    instanceId: DEFAULT_DISCORD_CONNECTOR_INSTANCE_ID,
-    contributionId: DISCORD_CONNECTOR_CONTRIBUTION_ID,
-  },
-};
-
-export function listInitProviderChoices(): ProviderCatalogEntry[] {
-  return Object.values(PROVIDER_CATALOG);
-}
-
-export function listInitConnectorChoices(): ConnectorCatalogEntry[] {
-  return Object.values(CONNECTOR_CATALOG);
-}
-
-export function isInitProviderChoiceId(value: string): value is InitProviderChoiceId {
-  return Object.prototype.hasOwnProperty.call(PROVIDER_CATALOG, value);
-}
-
-export function isInitConnectorChoiceId(value: string): value is InitConnectorChoiceId {
-  return Object.prototype.hasOwnProperty.call(CONNECTOR_CATALOG, value);
-}
-
-export function createInitSelectionConfig(
-  providerChoiceIds: InitProviderChoiceId[],
-  connectorChoiceId: InitConnectorChoiceId,
-  context: InitSelectionContext,
-): InitSelectionResult {
-  const dedupedProviderChoiceIds: InitProviderChoiceId[] = [];
-  const seenProviderChoiceIds = new Set<InitProviderChoiceId>();
-  for (const providerChoiceId of providerChoiceIds) {
-    if (!seenProviderChoiceIds.has(providerChoiceId)) {
-      seenProviderChoiceIds.add(providerChoiceId);
-      dedupedProviderChoiceIds.push(providerChoiceId);
-    }
-  }
-
-  if (dedupedProviderChoiceIds.length === 0) {
-    throw new Error("At least one provider choice is required");
-  }
-
-  if (!dedupedProviderChoiceIds.includes(context.routeProviderChoiceId)) {
-    throw new Error(
-      `route provider choice '${context.routeProviderChoiceId}' must be one of selected providers: ${dedupedProviderChoiceIds.join(", ")}`,
-    );
-  }
-
-  const providerChoices = dedupedProviderChoiceIds.map((providerChoiceId) => PROVIDER_CATALOG[providerChoiceId]);
-  const primaryProviderChoice = PROVIDER_CATALOG[context.routeProviderChoiceId];
-  const connectorChoice = CONNECTOR_CATALOG[connectorChoiceId];
-
-  return {
-    providerChoiceIds: dedupedProviderChoiceIds,
-    routeProviderChoiceId: primaryProviderChoice.id,
-    providerChoiceId: primaryProviderChoice.id,
-    connectorChoiceId,
-    extensionPackages: [
-      ...new Set([...providerChoices.map((item) => item.extensionPackage), connectorChoice.extensionPackage]),
-    ],
-    providerInstances: providerChoices.map((providerChoice) => ({
-      choiceId: providerChoice.id,
-      instanceId: providerChoice.instanceId,
-      contributionId: providerChoice.contributionId,
-      config: structuredClone(providerChoice.config),
-    })),
-    providerInstanceId: primaryProviderChoice.instanceId,
-    providerContributionId: primaryProviderChoice.contributionId,
-    providerConfig: structuredClone(primaryProviderChoice.config),
-    connectorInstanceId: connectorChoice.instanceId,
-    connectorContributionId: connectorChoice.contributionId,
-    connectorConfig: {
-      botName: context.botName,
-      botToken: context.botToken,
-      reconnectStaleMs: 60_000,
-      reconnectCheckIntervalMs: 10_000,
-    },
-    routeProfile: {
-      projectRoot: context.projectRoot,
-      tools: "full",
-      systemPromptFile: "",
-      mentions: context.allowAllMessages ? "optional" : "required",
-      provider: primaryProviderChoice.instanceId,
-      sandbox: "host.builtin",
-    },
-    bindingId: `${connectorChoice.instanceId}.${context.routeId}`,
-    bindingConfig: {
-      connector: connectorChoice.instanceId,
-      source: {
-        type: "channel",
-        id: context.channelId,
-      },
-      route: context.routeId,
-    },
-  };
-}

package/src/cli/shared/init-models-file.ts

@@ -1,77 +0,0 @@
-import { access, mkdir, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, resolve } from "node:path";
-import { homedir } from "node:os";
-
-const DEFAULT_PROVIDER_PI_MODELS_FILE = "./models.custom.json";
-
-const PROVIDER_PI_MODELS_TEMPLATE = {
-  providers: {
-    "custom-openai": {
-      baseUrl: "https://api.example.com/v1",
-      api: "openai-completions",
-      apiKey: "CUSTOM_PROVIDER_AUTH_TOKEN",
-      models: [
-        {
-          id: "example-model",
-          name: "example-model",
-          reasoning: false,
-          input: ["text"],
-          contextWindow: 128000,
-          maxTokens: 8192,
-          cost: {
-            input: 0,
-            output: 0,
-            cacheRead: 0,
-            cacheWrite: 0,
-          },
-        },
-      ],
-    },
-  },
-} as const;
-
-function expandHome(value: string): string {
-  if (value === "~") {
-    return homedir();
-  }
-  if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return resolve(homedir(), value.slice(2));
-  }
-
-  return value;
-}
-
-async function fileExists(path: string): Promise<boolean> {
-  try {
-    await access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function resolveModelsFilePath(configPath: string, value: string | undefined): string {
-  const configDir = dirname(resolve(configPath));
-  const resolvedValue = expandHome(value && value.trim().length > 0 ? value.trim() : DEFAULT_PROVIDER_PI_MODELS_FILE);
-  return isAbsolute(resolvedValue) ? resolve(resolvedValue) : resolve(configDir, resolvedValue);
-}
-
-/**
- * Creates provider.pi models file only when missing.
- */
-export async function ensureProviderPiModelsFile(
-  configPath: string,
-  providerConfig: Record<string, unknown>,
-): Promise<{ created: boolean; path: string }> {
-  const modelsFile = typeof providerConfig.modelsFile === "string" ? providerConfig.modelsFile : undefined;
-  const targetPath = resolveModelsFilePath(configPath, modelsFile);
-
-  if (await fileExists(targetPath)) {
-    return { created: false, path: targetPath };
-  }
-
-  await mkdir(dirname(targetPath), { recursive: true });
-  await writeFile(targetPath, `${JSON.stringify(PROVIDER_PI_MODELS_TEMPLATE, null, 2)}\n`, "utf-8");
-  return { created: true, path: targetPath };
-}
-

package/src/cli/shared/runtime.ts

@@ -1,33 +0,0 @@
-import { mkdir } from "node:fs/promises";
-import { join } from "node:path";
-import pino from "pino";
-import type { GatewayConfig } from "../../core/types.js";
-
-/**
- * Creates the shared gateway logger instance used across CLI commands.
- */
-export function createLogger() {
-  return pino({
-    name: "dobby",
-    level: process.env.LOG_LEVEL ?? "info",
-  });
-}
-
-/**
- * Returns the extension store directory from normalized gateway config.
- */
-export function extensionStoreDir(config: GatewayConfig): string {
-  return join(config.data.rootDir, "extensions");
-}
-
-/**
- * Ensures required runtime data directories exist before start/doctor operations.
- */
-export async function ensureDataDirs(rootDir: string): Promise<void> {
-  await mkdir(rootDir, { recursive: true });
-  await mkdir(join(rootDir, "sessions"), { recursive: true });
-  await mkdir(join(rootDir, "attachments"), { recursive: true });
-  await mkdir(join(rootDir, "logs"), { recursive: true });
-  await mkdir(join(rootDir, "state"), { recursive: true });
-  await mkdir(join(rootDir, "extensions"), { recursive: true });
-}

package/src/cli/shared/schema-prompts.ts

@@ -1,414 +0,0 @@
-import {
-  cancel,
-  confirm,
-  isCancel,
-  multiselect,
-  note,
-  select,
-  text,
-} from "@clack/prompts";
-import JSON5 from "json5";
-
-interface PromptConfigFromSchemaOptions {
-  title?: string;
-  promptDefaultedFields?: boolean;
-}
-
-interface FieldPromptDescriptor {
-  key: string;
-  schema: Record<string, unknown>;
-  required: boolean;
-  hasDefault: boolean;
-  existingValue: unknown;
-  initialValue: unknown;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
-function isPrimitive(value: unknown): value is string | number | boolean {
-  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-}
-
-function stringifyPreview(value: unknown): string {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (isPrimitive(value)) {
-    return String(value);
-  }
-  if (value === undefined) {
-    return "";
-  }
-  return JSON.stringify(value);
-}
-
-function schemaType(schema: Record<string, unknown>): string | undefined {
-  const raw = schema.type;
-  if (typeof raw === "string") {
-    return raw;
-  }
-  if (Array.isArray(raw)) {
-    const firstStringType = raw.find((item) => typeof item === "string");
-    return typeof firstStringType === "string" ? firstStringType : undefined;
-  }
-  return undefined;
-}
-
-function schemaEnum(schema: Record<string, unknown>): Array<string | number | boolean> | null {
-  if (!Array.isArray(schema.enum)) {
-    return null;
-  }
-
-  const normalized = schema.enum.filter((item) => isPrimitive(item)) as Array<string | number | boolean>;
-  return normalized.length > 0 ? normalized : null;
-}
-
-function schemaRequiredSet(schema: Record<string, unknown>): Set<string> {
-  if (!Array.isArray(schema.required)) {
-    return new Set<string>();
-  }
-  return new Set(schema.required.filter((item) => typeof item === "string"));
-}
-
-function schemaProperties(schema: Record<string, unknown>): Record<string, Record<string, unknown>> {
-  if (!isRecord(schema.properties)) {
-    return {};
-  }
-
-  const result: Record<string, Record<string, unknown>> = {};
-  for (const [key, value] of Object.entries(schema.properties)) {
-    if (isRecord(value)) {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-
-function hasSchemaDefault(schema: Record<string, unknown>): boolean {
-  return Object.prototype.hasOwnProperty.call(schema, "default");
-}
-
-function shouldPromptInMinimalMode(field: FieldPromptDescriptor): boolean {
-  if (!field.hasDefault && field.required) {
-    return true;
-  }
-
-  if (!field.hasDefault && field.existingValue === undefined) {
-    return true;
-  }
-
-  return false;
-}
-
-async function promptNumberField(params: {
-  message: string;
-  required: boolean;
-  initialValue: unknown;
-  integer: boolean;
-  existingValue: unknown;
-}): Promise<number | undefined> {
-  while (true) {
-    const result = await text({
-      message: params.message,
-      initialValue: stringifyPreview(params.initialValue),
-      placeholder: params.integer ? "integer" : "number",
-    });
-    if (isCancel(result)) {
-      cancel("Configuration cancelled.");
-      throw new Error("Configuration cancelled.");
-    }
-
-    const raw = String(result ?? "").trim();
-    if (raw.length === 0) {
-      if (params.required && params.existingValue === undefined) {
-        await note("This field is required.", "Validation");
-        continue;
-      }
-      return typeof params.existingValue === "number" ? params.existingValue : undefined;
-    }
-
-    const parsed = Number(raw);
-    if (!Number.isFinite(parsed)) {
-      await note("Please enter a valid number.", "Validation");
-      continue;
-    }
-    if (params.integer && !Number.isInteger(parsed)) {
-      await note("Please enter an integer.", "Validation");
-      continue;
-    }
-    return parsed;
-  }
-}
-
-async function promptJsonField(params: {
-  message: string;
-  required: boolean;
-  initialValue: unknown;
-  expected: "object" | "array";
-  existingValue: unknown;
-}): Promise<unknown> {
-  while (true) {
-    const result = await text({
-      message: params.message,
-      initialValue: stringifyPreview(params.initialValue),
-      placeholder: params.expected === "object" ? '{"key":"value"}' : '["value"]',
-    });
-    if (isCancel(result)) {
-      cancel("Configuration cancelled.");
-      throw new Error("Configuration cancelled.");
-    }
-
-    const raw = String(result ?? "").trim();
-    if (raw.length === 0) {
-      if (params.required && params.existingValue === undefined) {
-        await note("This field is required.", "Validation");
-        continue;
-      }
-      return params.existingValue;
-    }
-
-    try {
-      const parsed = JSON5.parse(raw);
-      if (params.expected === "object" && (!parsed || typeof parsed !== "object" || Array.isArray(parsed))) {
-        await note("Please enter a JSON object.", "Validation");
-        continue;
-      }
-      if (params.expected === "array" && !Array.isArray(parsed)) {
-        await note("Please enter a JSON array.", "Validation");
-        continue;
-      }
-      return parsed;
-    } catch (error) {
-      await note(`Invalid JSON: ${error instanceof Error ? error.message : String(error)}`, "Validation");
-    }
-  }
-}
-
-async function promptArrayField(params: {
-  key: string;
-  schema: Record<string, unknown>;
-  required: boolean;
-  initialValue: unknown;
-  existingValue: unknown;
-}): Promise<unknown> {
-  const itemSchema = isRecord(params.schema.items) ? params.schema.items : {};
-  const itemEnum = schemaEnum(itemSchema);
-  if (itemEnum && itemEnum.length > 0) {
-    const current = Array.isArray(params.initialValue) ? params.initialValue : [];
-    const initialValues = current.filter((item) => itemEnum.includes(item as string | number | boolean))
-      .map((item) => String(item));
-    const result = await multiselect({
-      message: `${params.key}${params.required ? " (required)" : ""}`,
-      options: itemEnum.map((item) => ({
-        value: String(item),
-        label: String(item),
-      })),
-      initialValues,
-      required: params.required,
-    });
-    if (isCancel(result)) {
-      cancel("Configuration cancelled.");
-      throw new Error("Configuration cancelled.");
-    }
-
-    return (result as string[]).map((value) => itemEnum.find((candidate) => String(candidate) === value) ?? value);
-  }
-
-  return promptJsonField({
-    message: `${params.key}${params.required ? " (required)" : ""} (JSON array)`,
-    required: params.required,
-    initialValue: params.initialValue,
-    expected: "array",
-    existingValue: params.existingValue,
-  });
-}
-
-async function promptFieldValue(params: {
-  key: string;
-  schema: Record<string, unknown>;
-  required: boolean;
-  initialValue: unknown;
-  existingValue: unknown;
-}): Promise<unknown> {
-  const { key, schema, required, initialValue, existingValue } = params;
-  const enumValues = schemaEnum(schema);
-  const type = schemaType(schema);
-  const description = typeof schema.description === "string" ? schema.description.trim() : "";
-  const message = `${key}${required ? " (required)" : ""}${description ? ` - ${description}` : ""}`;
-
-  if (enumValues && enumValues.length > 0) {
-    const fallback = enumValues[0]!;
-    const initialCandidate = enumValues.includes(initialValue as string | number | boolean)
-      ? (initialValue as string | number | boolean)
-      : enumValues.includes(existingValue as string | number | boolean)
-        ? (existingValue as string | number | boolean)
-        : fallback;
-    const result = await select({
-      message,
-      options: enumValues.map((value) => ({
-        value: String(value),
-        label: String(value),
-      })),
-      initialValue: String(initialCandidate),
-    });
-    if (isCancel(result)) {
-      cancel("Configuration cancelled.");
-      throw new Error("Configuration cancelled.");
-    }
-    return enumValues.find((value) => String(value) === String(result)) ?? result;
-  }
-
-  if (type === "boolean") {
-    const result = await confirm({
-      message,
-      initialValue: typeof initialValue === "boolean"
-        ? initialValue
-        : typeof existingValue === "boolean"
-          ? existingValue
-          : false,
-    });
-    if (isCancel(result)) {
-      cancel("Configuration cancelled.");
-      throw new Error("Configuration cancelled.");
-    }
-    return result === true;
-  }
-
-  if (type === "integer" || type === "number") {
-    return promptNumberField({
-      message,
-      required,
-      initialValue,
-      integer: type === "integer",
-      existingValue,
-    });
-  }
-
-  if (type === "array") {
-    return promptArrayField({
-      key,
-      schema,
-      required,
-      initialValue,
-      existingValue,
-    });
-  }
-
-  if (type === "object") {
-    return promptJsonField({
-      message: `${message} (JSON object)`,
-      required,
-      initialValue,
-      expected: "object",
-      existingValue,
-    });
-  }
-
-  while (true) {
-    const result = await text({
-      message,
-      initialValue: stringifyPreview(initialValue),
-    });
-    if (isCancel(result)) {
-      cancel("Configuration cancelled.");
-      throw new Error("Configuration cancelled.");
-    }
-
-    const raw = String(result ?? "").trim();
-    if (raw.length === 0) {
-      if (required && existingValue === undefined) {
-        await note("This field is required.", "Validation");
-        continue;
-      }
-      return existingValue;
-    }
-
-    return raw;
-  }
-}
-
-/**
- * Prompts one extension config object from a contribution JSON Schema.
- * Currently supports top-level schema properties and falls back to JSON input for complex fields.
- */
-export async function promptConfigFromSchema(
-  schema: Record<string, unknown>,
-  currentConfig: Record<string, unknown>,
-  options?: PromptConfigFromSchemaOptions,
-): Promise<Record<string, unknown>> {
-  const properties = schemaProperties(schema);
-  const required = schemaRequiredSet(schema);
-
-  if (options?.title) {
-    await note(options.title, "Configure");
-  }
-
-  if (Object.keys(properties).length === 0) {
-    return structuredClone(currentConfig);
-  }
-
-  const next = structuredClone(currentConfig);
-  const fieldDescriptors: FieldPromptDescriptor[] = Object.entries(properties).map(([key, fieldSchema]) => {
-    const existingValue = next[key];
-    const defaultValue = fieldSchema.default;
-    const initialValue = existingValue !== undefined ? existingValue : defaultValue;
-    return {
-      key,
-      schema: fieldSchema,
-      required: required.has(key),
-      hasDefault: hasSchemaDefault(fieldSchema),
-      existingValue,
-      initialValue,
-    };
-  });
-
-  const minimalFields = fieldDescriptors.filter((field) => shouldPromptInMinimalMode(field));
-  const advancedFields = fieldDescriptors.filter((field) => !minimalFields.includes(field));
-
-  for (const field of minimalFields) {
-    const value = await promptFieldValue({
-      key: field.key,
-      schema: field.schema,
-      required: field.required,
-      initialValue: field.initialValue,
-      existingValue: field.existingValue,
-    });
-    if (value === undefined) {
-      continue;
-    }
-    next[field.key] = value;
-  }
-
-  if (advancedFields.length > 0) {
-    const shouldPromptAdvanced = options?.promptDefaultedFields === true
-      ? true
-      : await confirm({
-        message: "Configure advanced options (defaults can be kept)?",
-        initialValue: false,
-      });
-    if (isCancel(shouldPromptAdvanced)) {
-      cancel("Configuration cancelled.");
-      throw new Error("Configuration cancelled.");
-    }
-
-    if (shouldPromptAdvanced === true) {
-      for (const field of advancedFields) {
-        const value = await promptFieldValue({
-          key: field.key,
-          schema: field.schema,
-          required: field.required,
-          initialValue: field.initialValue,
-          existingValue: field.existingValue,
-        });
-        if (value === undefined) {
-          continue;
-        }
-        next[field.key] = value;
-      }
-    }
-  }
-
-  return next;
-}