neondeck 1.0.0-beta.10

package/src/modules/repos/model-discovery.ts

@@ -0,0 +1,233 @@
+import { registeredProviderIds, type RegisteredProviderId } from './providers';
+
+export type DiscoveredModel = {
+  id: string;
+  provider: RegisteredProviderId;
+  model: string;
+  name: string;
+  contextLength: number | null;
+  reasoning: boolean;
+  isFree: boolean | null;
+  recommendedIndex: number | null;
+};
+
+export type ModelDiscoveryResult = {
+  ok: boolean;
+  provider: RegisteredProviderId;
+  models: DiscoveredModel[];
+  error?: string;
+};
+
+type KiloRawModel = {
+  id?: unknown;
+  name?: unknown;
+  context_length?: unknown;
+  architecture?: {
+    output_modalities?: unknown;
+  };
+  supported_parameters?: unknown;
+  preferredIndex?: unknown;
+  isFree?: unknown;
+};
+
+const kiloApiBase = 'https://api.kilo.ai';
+const kiloFetchTimeoutMs = 10_000;
+
+export async function discoverModels(input: {
+  provider: RegisteredProviderId;
+  apiKey?: string;
+  organizationId?: string;
+  signal?: AbortSignal;
+}): Promise<ModelDiscoveryResult> {
+  if (input.provider === 'kilocode') {
+    return discoverKilocodeModels({ ...input, provider: 'kilocode' });
+  }
+
+  return {
+    ok: true,
+    provider: input.provider,
+    models: suggestedModels(input.provider),
+  };
+}
+
+export function suggestedModels(
+  provider: RegisteredProviderId,
+): DiscoveredModel[] {
+  if (provider === 'openai') {
+    return [
+      suggestedModel('openai', 'gpt-5.5', 'GPT-5.5', true, 0),
+      suggestedModel('openai', 'gpt-5', 'GPT-5', true, 1),
+      suggestedModel('openai', 'gpt-5-mini', 'GPT-5 Mini', true, 2),
+    ];
+  }
+
+  if (provider === 'anthropic') {
+    return [
+      suggestedModel(
+        'anthropic',
+        'claude-sonnet-4-6',
+        'Claude Sonnet 4.6',
+        true,
+        0,
+      ),
+      suggestedModel(
+        'anthropic',
+        'claude-opus-4-1',
+        'Claude Opus 4.1',
+        true,
+        1,
+      ),
+    ];
+  }
+
+  return [
+    suggestedModel(
+      'kilocode',
+      'kilo-auto/balanced',
+      'Kilo Auto Balanced',
+      true,
+      0,
+    ),
+    suggestedModel('kilocode', 'kilo-auto/free', 'Kilo Auto Free', true, 1),
+  ];
+}
+
+export function isDiscoverableProvider(
+  provider: string,
+): provider is RegisteredProviderId {
+  return registeredProviderIds.includes(provider as RegisteredProviderId);
+}
+
+async function discoverKilocodeModels(input: {
+  provider: 'kilocode';
+  apiKey?: string;
+  organizationId?: string;
+  signal?: AbortSignal;
+}): Promise<ModelDiscoveryResult> {
+  const organizationId = input.organizationId?.trim();
+  const baseUrl = organizationId
+    ? `${kiloApiBase}/api/organizations/${encodeURIComponent(organizationId)}`
+    : `${kiloApiBase}/api/openrouter`;
+  const response: Response | Error = await fetch(`${baseUrl}/models`, {
+    headers: {
+      'Content-Type': 'application/json',
+      ...(input.apiKey ? { Authorization: `Bearer ${input.apiKey}` } : {}),
+      ...(organizationId
+        ? { 'X-KiloCode-OrganizationId': organizationId }
+        : {}),
+    },
+    signal: combinedSignal(input.signal),
+  }).catch((error: unknown) =>
+    error instanceof Error ? error : new Error(String(error)),
+  );
+
+  if (response instanceof Error) {
+    return {
+      ok: false,
+      provider: 'kilocode',
+      models: suggestedModels('kilocode'),
+      error: response.message,
+    };
+  }
+
+  if (!response.ok) {
+    if ((response.status === 401 || response.status === 403) && input.apiKey) {
+      return discoverKilocodeModels({ provider: 'kilocode' });
+    }
+
+    return {
+      ok: false,
+      provider: 'kilocode',
+      models: suggestedModels('kilocode'),
+      error: `Kilo model discovery returned HTTP ${response.status}.`,
+    };
+  }
+
+  const data = (await response.json().catch(() => null)) as {
+    data?: unknown;
+  } | null;
+  const rows = Array.isArray(data?.data) ? data.data : null;
+  if (!rows) {
+    return {
+      ok: false,
+      provider: 'kilocode',
+      models: suggestedModels('kilocode'),
+      error: 'Kilo model discovery returned an unexpected response.',
+    };
+  }
+
+  const models = rows
+    .map((row) => kiloModel(row))
+    .filter((model): model is DiscoveredModel => Boolean(model))
+    .sort(compareModels);
+
+  return {
+    ok: true,
+    provider: 'kilocode',
+    models: models.length > 0 ? models : suggestedModels('kilocode'),
+  };
+}
+
+function kiloModel(row: unknown): DiscoveredModel | null {
+  const model = row as KiloRawModel;
+  if (typeof model.id !== 'string' || model.id.trim().length === 0) {
+    return null;
+  }
+
+  const outputModalities = model.architecture?.output_modalities;
+  if (Array.isArray(outputModalities) && outputModalities.includes('image')) {
+    return null;
+  }
+
+  const supportedParameters = model.supported_parameters;
+  if (
+    !Array.isArray(supportedParameters) ||
+    !supportedParameters.includes('tools')
+  ) {
+    return null;
+  }
+
+  return {
+    id: `kilocode/${model.id}`,
+    provider: 'kilocode',
+    model: model.id,
+    name: typeof model.name === 'string' ? model.name : model.id,
+    contextLength:
+      typeof model.context_length === 'number' ? model.context_length : null,
+    reasoning: supportedParameters.includes('reasoning'),
+    isFree: typeof model.isFree === 'boolean' ? model.isFree : null,
+    recommendedIndex:
+      typeof model.preferredIndex === 'number' ? model.preferredIndex : null,
+  };
+}
+
+function suggestedModel(
+  provider: RegisteredProviderId,
+  model: string,
+  name: string,
+  reasoning: boolean,
+  recommendedIndex: number,
+): DiscoveredModel {
+  return {
+    id: `${provider}/${model}`,
+    provider,
+    model,
+    name,
+    contextLength: null,
+    reasoning,
+    isFree: null,
+    recommendedIndex,
+  };
+}
+
+function compareModels(left: DiscoveredModel, right: DiscoveredModel) {
+  const leftIndex = left.recommendedIndex ?? Number.POSITIVE_INFINITY;
+  const rightIndex = right.recommendedIndex ?? Number.POSITIVE_INFINITY;
+  if (leftIndex !== rightIndex) return leftIndex - rightIndex;
+  return left.id.localeCompare(right.id);
+}
+
+function combinedSignal(signal?: AbortSignal) {
+  const timeout = AbortSignal.timeout(kiloFetchTimeoutMs);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}

package/src/modules/repos/providers.ts

@@ -0,0 +1,194 @@
+import type { ProviderRegistration } from '@flue/runtime';
+import {
+  ensureRuntimeHomeSync,
+  parseAppConfig,
+  readRuntimeJsonSync,
+  runtimePaths,
+  type AppConfig,
+  type RuntimePaths,
+} from '../../runtime-home';
+
+export const registeredProviderIds = [
+  'kilocode',
+  'openai',
+  'anthropic',
+] as const;
+
+export type RegisteredProviderId = (typeof registeredProviderIds)[number];
+
+export type KilocodeProviderStatus = {
+  id: 'kilocode';
+  allowed: true;
+  enabled: boolean;
+  apiKeyEnv: string;
+  organizationIdEnv: string | null;
+  apiKeyPresent: boolean;
+  organizationIdPresent: boolean;
+};
+
+export type ApiKeyProviderStatus = {
+  id: 'openai' | 'anthropic';
+  allowed: true;
+  enabled: boolean;
+  apiKeyEnv: string;
+  apiKeyPresent: boolean;
+};
+
+export type ProviderRuntimeRegistration = {
+  id: RegisteredProviderId;
+  registration: ProviderRegistration;
+};
+
+const defaultKilocodeApiKeyEnv = 'KILOCODE_API_KEY';
+const defaultKilocodeOrganizationIdEnv = 'KILOCODE_ORGANIZATION_ID';
+const defaultOpenAiApiKeyEnv = 'OPENAI_API_KEY';
+const defaultAnthropicApiKeyEnv = 'ANTHROPIC_API_KEY';
+const kilocodeGatewayBaseUrl = 'https://api.kilo.ai/api/gateway';
+const kilocodeGatewayMaxTokens = 16_384;
+
+export function readKilocodeProviderCredentials(
+  env: NodeJS.ProcessEnv = process.env,
+  config?: Pick<AppConfig, 'providers'>,
+) {
+  const status = resolveKilocodeProviderStatus(config, env);
+  if (!status.enabled) {
+    return {
+      apiKey: undefined,
+      organizationId: undefined,
+    };
+  }
+
+  return {
+    apiKey: env[status.apiKeyEnv],
+    organizationId: status.organizationIdEnv
+      ? env[status.organizationIdEnv]
+      : undefined,
+  };
+}
+
+export function readProviderConfigSync(paths: RuntimePaths = runtimePaths()) {
+  ensureRuntimeHomeSync(paths);
+  return readRuntimeJsonSync(paths.config, parseAppConfig);
+}
+
+export function providerRuntimeRegistrations(
+  env: NodeJS.ProcessEnv = process.env,
+  config?: Pick<AppConfig, 'providers'>,
+): ProviderRuntimeRegistration[] {
+  const registrations: ProviderRuntimeRegistration[] = [];
+  const kilocode = resolveKilocodeProviderStatus(config, env);
+  if (kilocode.enabled) {
+    const organizationId = kilocode.organizationIdEnv
+      ? env[kilocode.organizationIdEnv]
+      : undefined;
+    registrations.push({
+      id: 'kilocode',
+      registration: {
+        api: 'openai-completions',
+        baseUrl: kilocodeGatewayBaseUrl,
+        maxTokens: kilocodeGatewayMaxTokens,
+        apiKey: env[kilocode.apiKeyEnv] ?? '',
+        headers: organizationId
+          ? { 'X-KiloCode-OrganizationId': organizationId }
+          : undefined,
+      },
+    });
+  }
+
+  registrations.push(
+    apiKeyProviderRuntimeRegistration(
+      resolveOpenAiProviderStatus(config, env),
+      env,
+    ),
+    apiKeyProviderRuntimeRegistration(
+      resolveAnthropicProviderStatus(config, env),
+      env,
+    ),
+  );
+
+  return registrations;
+}
+
+export function resolveKilocodeProviderStatus(
+  config?: Pick<AppConfig, 'providers'>,
+  env: NodeJS.ProcessEnv = process.env,
+): KilocodeProviderStatus {
+  const kilocode = config?.providers?.kilocode;
+  const apiKeyEnv = kilocode?.apiKeyEnv ?? defaultKilocodeApiKeyEnv;
+  const organizationIdEnv =
+    kilocode?.organizationIdEnv ??
+    (env[defaultKilocodeOrganizationIdEnv]
+      ? defaultKilocodeOrganizationIdEnv
+      : null);
+
+  return {
+    id: 'kilocode',
+    allowed: true,
+    enabled: kilocode?.enabled ?? true,
+    apiKeyEnv,
+    organizationIdEnv,
+    apiKeyPresent: Boolean(env[apiKeyEnv]),
+    organizationIdPresent: organizationIdEnv
+      ? Boolean(env[organizationIdEnv])
+      : false,
+  };
+}
+
+export function resolveOpenAiProviderStatus(
+  config?: Pick<AppConfig, 'providers'>,
+  env: NodeJS.ProcessEnv = process.env,
+): ApiKeyProviderStatus {
+  return resolveApiKeyProviderStatus(
+    'openai',
+    config?.providers?.openai,
+    defaultOpenAiApiKeyEnv,
+    env,
+  );
+}
+
+export function resolveAnthropicProviderStatus(
+  config?: Pick<AppConfig, 'providers'>,
+  env: NodeJS.ProcessEnv = process.env,
+): ApiKeyProviderStatus {
+  return resolveApiKeyProviderStatus(
+    'anthropic',
+    config?.providers?.anthropic,
+    defaultAnthropicApiKeyEnv,
+    env,
+  );
+}
+
+export function isRegisteredProvider(
+  provider: string,
+): provider is RegisteredProviderId {
+  return registeredProviderIds.includes(provider as RegisteredProviderId);
+}
+
+function resolveApiKeyProviderStatus(
+  id: ApiKeyProviderStatus['id'],
+  config: { enabled?: boolean; apiKeyEnv?: string } | undefined,
+  defaultApiKeyEnv: string,
+  env: NodeJS.ProcessEnv,
+): ApiKeyProviderStatus {
+  const apiKeyEnv = config?.apiKeyEnv ?? defaultApiKeyEnv;
+
+  return {
+    id,
+    allowed: true,
+    enabled: config?.enabled ?? true,
+    apiKeyEnv,
+    apiKeyPresent: Boolean(env[apiKeyEnv]),
+  };
+}
+
+function apiKeyProviderRuntimeRegistration(
+  status: ApiKeyProviderStatus,
+  env: NodeJS.ProcessEnv,
+): ProviderRuntimeRegistration {
+  return {
+    id: status.id,
+    registration: {
+      apiKey: status.enabled ? (env[status.apiKeyEnv] ?? '') : '',
+    },
+  };
+}

package/src/modules/repos/registry.ts

@@ -0,0 +1,232 @@
+import { runExecFile } from '../../lib/exec';
+import { gitDiff } from '../../repo-edit/git';
+import {
+  type RepoConfig,
+  type RuntimePaths,
+  ensureRuntimeHome,
+  parseRepoRegistry,
+  readRuntimeJson,
+  runtimePaths,
+} from '../../runtime-home';
+import { listActiveRepoWorktrees, type WorktreeRecord } from '../worktrees';
+
+export type RepoRegistrySnapshot = {
+  home: string;
+  path: string;
+  repos: Array<RepoConfig & { activeWorktrees?: RepoRegistryWorktreeLink[] }>;
+  count: number;
+  fetchedAt: string;
+};
+
+export type RepoRegistryWorktreeLink = Pick<
+  WorktreeRecord,
+  | 'id'
+  | 'prNumber'
+  | 'headRef'
+  | 'headSha'
+  | 'localPath'
+  | 'lifecycleStatus'
+  | 'adopted'
+  | 'updatedAt'
+>;
+
+export type RepoHealth = {
+  id: string;
+  repo: string;
+  path: string;
+  branch: string | null;
+  defaultBranch: string;
+  dirty: boolean;
+  changeCount: number;
+  ahead: number | null;
+  behind: number | null;
+  changes: string[];
+  error?: string;
+};
+
+export type RepoHealthSnapshot = {
+  home: string;
+  path: string;
+  repos: RepoHealth[];
+  attention: RepoHealth[];
+  count: number;
+  fetchedAt: string;
+};
+
+export type RepoDiffSummary = {
+  ok: boolean;
+  repo: string;
+  path: string;
+  baseRef: string;
+  files: Array<{
+    path: string;
+    status: string;
+    additions: number;
+    deletions: number;
+  }>;
+  fileCount: number;
+  additions: number;
+  deletions: number;
+  binaryFiles: number;
+  error?: string;
+};
+
+export async function readRepoRegistrySnapshot(
+  paths: RuntimePaths = runtimePaths(),
+): Promise<RepoRegistrySnapshot> {
+  await ensureRuntimeHome(paths);
+  const registry = await readRuntimeJson(paths.repos, parseRepoRegistry);
+
+  return {
+    home: paths.home,
+    path: paths.repos,
+    repos: registry.repos.map((repo) => ({
+      ...repo,
+      activeWorktrees: listActiveRepoWorktrees(repo.id, paths).map(
+        worktreeLink,
+      ),
+    })),
+    count: registry.repos.length,
+    fetchedAt: new Date().toISOString(),
+  };
+}
+
+export async function readRepoHealthSnapshot(
+  paths: RuntimePaths = runtimePaths(),
+): Promise<RepoHealthSnapshot> {
+  const registry = await readRepoRegistrySnapshot(paths);
+  const repos = await Promise.all(registry.repos.map(readGitRepoStatus));
+
+  return {
+    home: registry.home,
+    path: registry.path,
+    repos,
+    attention: repos.filter((repo) => repo.dirty || repo.error),
+    count: repos.length,
+    fetchedAt: new Date().toISOString(),
+  };
+}
+
+export async function readGitRepoStatus(repo: {
+  id: string;
+  path: string;
+  github: { owner: string; name: string };
+  defaultBranch: string;
+}): Promise<RepoHealth> {
+  try {
+    const [branch, status, upstream] = await Promise.all([
+      git(repo.path, ['rev-parse', '--abbrev-ref', 'HEAD']),
+      git(repo.path, ['status', '--porcelain=v1', '--untracked-files=all']),
+      git(repo.path, [
+        'rev-list',
+        '--left-right',
+        '--count',
+        '@{upstream}...HEAD',
+      ])
+        .then((output) => {
+          const [behind, ahead] = output.trim().split(/\s+/).map(Number);
+          return { ahead: ahead || 0, behind: behind || 0 };
+        })
+        .catch(() => ({ ahead: null, behind: null })),
+    ]);
+    const changes = status
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean);
+
+    return {
+      id: repo.id,
+      repo: repoFullName(repo),
+      path: repo.path,
+      branch: branch.trim(),
+      defaultBranch: repo.defaultBranch,
+      dirty: changes.length > 0,
+      changeCount: changes.length,
+      ahead: upstream.ahead,
+      behind: upstream.behind,
+      changes: changes.slice(0, 20),
+    };
+  } catch (error) {
+    return {
+      id: repo.id,
+      repo: repoFullName(repo),
+      path: repo.path,
+      branch: null,
+      defaultBranch: repo.defaultBranch,
+      dirty: false,
+      changeCount: 0,
+      ahead: null,
+      behind: null,
+      changes: [],
+      error: errorMessage(error),
+    };
+  }
+}
+
+export async function readGitDiffSummary(repo: {
+  path: string;
+  github: { owner: string; name: string };
+  defaultBranch: string;
+}): Promise<RepoDiffSummary> {
+  const baseRef = repo.defaultBranch.trim() || 'HEAD';
+  try {
+    const diff = await gitDiff(repo.path, { base: baseRef });
+    const files = diff.files;
+
+    return {
+      ok: true,
+      repo: repoFullName(repo),
+      path: repo.path,
+      baseRef,
+      files: files.map((file) => ({
+        path: file.path,
+        status: file.status,
+        additions: file.additions,
+        deletions: file.deletions,
+      })),
+      fileCount: files.length,
+      additions: files.reduce((sum, file) => sum + file.additions, 0),
+      deletions: files.reduce((sum, file) => sum + file.deletions, 0),
+      binaryFiles: files.filter((file) => file.binary).length,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      repo: repoFullName(repo),
+      path: repo.path,
+      baseRef: repo.defaultBranch.trim() || 'HEAD',
+      files: [],
+      fileCount: 0,
+      additions: 0,
+      deletions: 0,
+      binaryFiles: 0,
+      error: errorMessage(error),
+    };
+  }
+}
+
+export function repoFullName(repo: Pick<RepoConfig, 'github'>) {
+  return `${repo.github.owner}/${repo.github.name}`;
+}
+
+async function git(cwd: string, args: string[]) {
+  const { stdout } = await runExecFile('git', args, { cwd });
+  return stdout;
+}
+
+function errorMessage(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function worktreeLink(worktree: WorktreeRecord): RepoRegistryWorktreeLink {
+  return {
+    id: worktree.id,
+    prNumber: worktree.prNumber,
+    headRef: worktree.headRef,
+    headSha: worktree.headSha,
+    localPath: worktree.localPath,
+    lifecycleStatus: worktree.lifecycleStatus,
+    adopted: worktree.adopted,
+    updatedAt: worktree.updatedAt,
+  };
+}