neondeck 1.0.0-beta.4

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,
+  };
+}

package/src/modules/runtime/agent-config.ts

@@ -0,0 +1,167 @@
+import {
+  type AppConfig,
+  ensureRuntimeHomeSync,
+  parseAppConfig,
+  readRuntimeJsonSync,
+  runtimePaths,
+  type RuntimePaths,
+  type ThinkingLevel,
+} from '../../runtime-home';
+
+export const defaultAgentModel = 'kilocode/kilo-auto/balanced';
+export const defaultThinkingLevel: ThinkingLevel = 'medium';
+
+export type NeondeckSubagentKey =
+  'repoResearcher' | 'ciInvestigator' | 'releaseReviewer';
+
+export type AgentModelSelection = {
+  displayAssistant: string;
+  displayAssistantThinkingLevel: ThinkingLevel;
+  utility: string;
+  utilityConfigured: boolean;
+  utilityThinkingLevel: ThinkingLevel;
+  selfImprovement: string;
+  selfImprovementConfigured: boolean;
+  selfImprovementThinkingLevel: ThinkingLevel;
+  subagents: Record<NeondeckSubagentKey, string>;
+  subagentThinkingLevels: Record<NeondeckSubagentKey, ThinkingLevel>;
+};
+
+export function readAgentModelSelectionSync(
+  paths: RuntimePaths = runtimePaths(),
+): AgentModelSelection {
+  ensureRuntimeHomeSync(paths);
+
+  try {
+    const config = readRuntimeJsonSync(paths.config, parseAppConfig);
+    return resolveAgentModelSelection(config);
+  } catch (error) {
+    console.warn('[neondeck] failed to read agent model config', error);
+    return resolveAgentModelSelection();
+  }
+}
+
+export function resolveAgentModelSelection(
+  config?: Pick<AppConfig, 'models'>,
+  env: NodeJS.ProcessEnv = process.env,
+): AgentModelSelection {
+  const displayAssistant = firstModel(
+    config?.models?.displayAssistant,
+    config?.models?.default,
+    env.FLUE_AGENT_MODEL,
+    defaultAgentModel,
+  );
+  const displayAssistantThinkingLevel = firstThinkingLevel(
+    config?.models?.displayAssistantThinkingLevel,
+    config?.models?.defaultThinkingLevel,
+    env.FLUE_AGENT_THINKING_LEVEL,
+    defaultThinkingLevel,
+  );
+  const configuredUtility = firstOptionalModel(
+    config?.models?.utility,
+    env.FLUE_UTILITY_MODEL,
+  );
+  const utility = configuredUtility ?? displayAssistant;
+  const utilityThinkingLevel = firstThinkingLevel(
+    config?.models?.utilityThinkingLevel,
+    env.FLUE_UTILITY_THINKING_LEVEL,
+    'low',
+  );
+  const configuredSelfImprovement = firstOptionalModel(
+    config?.models?.selfImprovement,
+    env.FLUE_SELF_IMPROVEMENT_MODEL,
+  );
+  const selfImprovement = firstModel(
+    configuredSelfImprovement,
+    configuredUtility,
+    env.FLUE_UTILITY_MODEL,
+    displayAssistant,
+  );
+  const selfImprovementThinkingLevel = firstThinkingLevel(
+    config?.models?.selfImprovementThinkingLevel,
+    env.FLUE_SELF_IMPROVEMENT_THINKING_LEVEL,
+    config?.models?.utilityThinkingLevel,
+    env.FLUE_UTILITY_THINKING_LEVEL,
+    'low',
+  );
+  const subagentDefault = firstModel(
+    config?.models?.subagents?.default,
+    env.FLUE_SUBAGENT_MODEL,
+    config?.models?.default,
+    displayAssistant,
+  );
+  const subagentThinkingDefault = firstThinkingLevel(
+    config?.models?.subagents?.defaultThinkingLevel,
+    env.FLUE_SUBAGENT_THINKING_LEVEL,
+    config?.models?.defaultThinkingLevel,
+    displayAssistantThinkingLevel,
+  );
+
+  return {
+    displayAssistant,
+    displayAssistantThinkingLevel,
+    utility,
+    utilityConfigured: Boolean(configuredUtility),
+    utilityThinkingLevel,
+    selfImprovement,
+    selfImprovementConfigured: Boolean(configuredSelfImprovement),
+    selfImprovementThinkingLevel,
+    subagents: {
+      repoResearcher: firstModel(
+        config?.models?.subagents?.repoResearcher,
+        subagentDefault,
+      ),
+      ciInvestigator: firstModel(
+        config?.models?.subagents?.ciInvestigator,
+        subagentDefault,
+      ),
+      releaseReviewer: firstModel(
+        config?.models?.subagents?.releaseReviewer,
+        subagentDefault,
+      ),
+    },
+    subagentThinkingLevels: {
+      repoResearcher: firstThinkingLevel(
+        config?.models?.subagents?.repoResearcherThinkingLevel,
+        subagentThinkingDefault,
+      ),
+      ciInvestigator: firstThinkingLevel(
+        config?.models?.subagents?.ciInvestigatorThinkingLevel,
+        subagentThinkingDefault,
+      ),
+      releaseReviewer: firstThinkingLevel(
+        config?.models?.subagents?.releaseReviewerThinkingLevel,
+        subagentThinkingDefault,
+      ),
+    },
+  };
+}
+
+export function firstModel(...values: Array<string | undefined>) {
+  return firstOptionalModel(...values) ?? defaultAgentModel;
+}
+
+function firstOptionalModel(...values: Array<string | undefined>) {
+  return values.find((value) => value && value.trim().length > 0)?.trim();
+}
+
+export function firstThinkingLevel(
+  ...values: Array<string | undefined>
+): ThinkingLevel {
+  const value = values
+    .find((item) => item && isThinkingLevel(item.trim()))
+    ?.trim();
+
+  return value ? (value as ThinkingLevel) : defaultThinkingLevel;
+}
+
+export function isThinkingLevel(value: string): value is ThinkingLevel {
+  return (
+    value === 'off' ||
+    value === 'minimal' ||
+    value === 'low' ||
+    value === 'medium' ||
+    value === 'high' ||
+    value === 'xhigh'
+  );
+}