neondeck 1.0.0-beta.4

package/src/modules/commands/schemas.ts

@@ -0,0 +1,107 @@
+import type { JsonValue } from '@flue/runtime';
+import type { WorkflowSummaryRecord } from '../app-state';
+import type { fetchGitHubLogin, fetchPullRequestQueue } from '../github';
+import type { CiFixRunInput, createCiFailureDossierReport } from '../autopilot';
+import type { PrReviewAssistInput } from '../pr-review-assist';
+import type { addPrWatch } from '../watches';
+import * as v from 'valibot';
+
+export type NeonCommandName =
+  | 'repo-status'
+  | 'review-queue'
+  | 'review-pr'
+  | 'fix-ci'
+  | 'explain-ci'
+  | 'summarize-pr'
+  | 'draft-pr-description'
+  | 'prepare-pr'
+  | 'review-local'
+  | 'briefing'
+  | 'reasoning'
+  | 'memory'
+  | 'watch-pr'
+  | 'dev-doctor';
+
+export type ParsedNeonCommand = {
+  name: NeonCommandName;
+  args: string[];
+  raw: string;
+};
+
+export type NeonCommandResult = {
+  ok: boolean;
+  command: NeonCommandName;
+  input: string;
+  status: 'completed' | 'failed' | 'needs-config';
+  message: string;
+  data?: JsonValue;
+  errors?: string[];
+  requires?: string[];
+  workflowSummary?: WorkflowSummaryRecord;
+};
+
+export type CommandDependencies = {
+  fetchPullRequestQueue?: typeof fetchPullRequestQueue;
+  fetchGitHubLogin?: typeof fetchGitHubLogin;
+  invokeReviewPrWorkflow?: (
+    input: PrReviewAssistInput,
+  ) => Promise<{ runId: string }>;
+  invokeFixCiWorkflow?: (input: CiFixRunInput) => Promise<{ runId: string }>;
+  createCiFailureDossierReport?: typeof createCiFailureDossierReport;
+  addPrWatch?: typeof addPrWatch;
+};
+
+export type CommandExecutionContext = {
+  sessionId?: string;
+  surface?: string;
+};
+
+export type ReviewQueueAction = {
+  title: string;
+  reason: string;
+  priority: 'urgent' | 'high' | 'medium' | 'low';
+  url?: string | null;
+  repo?: string;
+  number?: number;
+};
+
+export const commandRunInputSchema = v.object({
+  command: v.pipe(v.string(), v.minLength(1)),
+  sessionId: v.optional(v.pipe(v.string(), v.minLength(1))),
+  surface: v.optional(v.pipe(v.string(), v.minLength(1), v.maxLength(64))),
+});
+export const workflowSummaryRecordSchema = v.looseObject({
+  id: v.string(),
+  workflow: v.string(),
+  runId: v.nullable(v.string()),
+  status: v.string(),
+  summary: v.nullable(v.unknown()),
+  createdAt: v.string(),
+  updatedAt: v.string(),
+});
+export const supportedCommandSchema = v.object({
+  name: v.string(),
+  usage: v.string(),
+  description: v.string(),
+});
+export const commandRunOutputSchema = v.looseObject({
+  ok: v.boolean(),
+  command: v.string(),
+  input: v.string(),
+  status: v.picklist(['completed', 'failed', 'needs-config']),
+  message: v.string(),
+  data: v.optional(v.unknown()),
+  errors: v.optional(v.array(v.string())),
+  requires: v.optional(v.array(v.string())),
+  workflowSummary: v.optional(workflowSummaryRecordSchema),
+});
+export const commandActionOutputSchema = v.looseObject({
+  ok: v.boolean(),
+  action: v.string(),
+  changed: v.boolean(),
+  message: v.optional(v.string()),
+  commands: v.optional(v.array(supportedCommandSchema)),
+  summaries: v.optional(v.array(workflowSummaryRecordSchema)),
+  errors: v.optional(v.array(v.string())),
+  requires: v.optional(v.array(v.string())),
+});

package/src/modules/commands/summaries.ts

@@ -0,0 +1,92 @@
+import { asJsonValue } from '../../lib/action-result';
+import type { NeonCommandName, NeonCommandResult } from './schemas';
+
+export function compactCommandSummary(result: NeonCommandResult) {
+  if (
+    result.command === 'review-queue' &&
+    result.data &&
+    typeof result.data === 'object'
+  ) {
+    const data = result.data as {
+      fetchedAt?: unknown;
+      login?: unknown;
+      repos?: unknown;
+      count?: unknown;
+      truncated?: unknown;
+      issues?: unknown;
+      triage?: unknown;
+      topActions?: unknown;
+    };
+
+    return {
+      ok: result.ok,
+      command: result.command,
+      input: result.input,
+      status: result.status,
+      message: result.message,
+      fetchedAt: data.fetchedAt,
+      login: data.login,
+      repos: data.repos,
+      count: data.count,
+      truncated: data.truncated,
+      issues: data.issues,
+      triage: data.triage,
+      topActions: data.topActions,
+    };
+  }
+
+  return result;
+}
+
+export function completedCommand(
+  command: NeonCommandName,
+  input: string,
+  message: string,
+  data: unknown,
+): NeonCommandResult {
+  return {
+    ok: true,
+    command,
+    input,
+    status: 'completed',
+    message,
+    data: asJsonValue(data),
+  };
+}
+
+export function needsConfigCommand(
+  command: NeonCommandName,
+  input: string,
+  message: string,
+  details: Pick<NeonCommandResult, 'errors' | 'requires'>,
+): NeonCommandResult {
+  return {
+    ok: false,
+    command,
+    input,
+    status: 'needs-config',
+    message,
+    ...(details.errors ? { errors: details.errors } : {}),
+    ...(details.requires ? { requires: details.requires } : {}),
+  };
+}
+
+export function failedCommand(
+  command: NeonCommandName,
+  input: string,
+  message: string,
+  details: Pick<NeonCommandResult, 'errors' | 'requires'> & {
+    data?: unknown;
+  } = {},
+): NeonCommandResult {
+  return {
+    ok: false,
+    command,
+    input,
+    status: 'failed',
+    message,
+    ...(details.errors ? { errors: details.errors } : {}),
+    ...(details.requires ? { requires: details.requires } : {}),
+    ...(details.data ? { data: asJsonValue(details.data) } : {}),
+  };
+}

package/src/modules/commands/utils.ts

@@ -0,0 +1,113 @@
+import type { JsonValue } from '@flue/runtime';
+import type { MemoryScope } from '../memory';
+import type { ThinkingLevel } from '../../runtime-home';
+
+export const allThinkingLevels: ThinkingLevel[] = [
+  'off',
+  'minimal',
+  'low',
+  'medium',
+  'high',
+  'xhigh',
+];
+
+export function supportedReasoningLevelsForModel(
+  model: string,
+): ThinkingLevel[] {
+  const specifier = parseModelSpecifier(model);
+  if (!specifier) return ['off'];
+
+  if (specifier.provider === 'openai') {
+    return isOpenAiReasoningModel(specifier.model)
+      ? allThinkingLevels
+      : ['off'];
+  }
+
+  if (specifier.provider === 'anthropic') {
+    return isAnthropicReasoningModel(specifier.model)
+      ? allThinkingLevels
+      : ['off'];
+  }
+
+  if (specifier.provider === 'kilocode') {
+    return isKilocodeReasoningModel(specifier.model)
+      ? allThinkingLevels
+      : ['off'];
+  }
+
+  return ['off'];
+}
+
+export function parseModelSpecifier(model: string) {
+  const slash = model.indexOf('/');
+  if (slash <= 0 || slash === model.length - 1) return null;
+  return {
+    provider: model.slice(0, slash),
+    model: model.slice(slash + 1),
+  };
+}
+
+export function isOpenAiReasoningModel(model: string) {
+  return /^(gpt-5|o[1-9])(?:[.-]|$)/i.test(model);
+}
+
+export function isAnthropicReasoningModel(model: string) {
+  return /^claude-(?:.*-4|3-7)(?:[.-]|$)/i.test(model);
+}
+
+export function isKilocodeReasoningModel(model: string) {
+  const nested = parseModelSpecifier(model);
+  if (nested?.provider === 'openai') {
+    return isOpenAiReasoningModel(nested.model);
+  }
+  if (nested?.provider === 'anthropic') {
+    return isAnthropicReasoningModel(nested.model);
+  }
+
+  return (
+    /^kilo-auto(?:\/|$)/i.test(model) ||
+    isOpenAiReasoningModel(model) ||
+    isAnthropicReasoningModel(model) ||
+    /(?:^|\/)(deepseek-r1|qwen.*thinking|.*reasoning.*)(?:[/:.-]|$)/i.test(
+      model,
+    )
+  );
+}
+
+export function formatList(values: string[]) {
+  if (values.length === 0) return 'no';
+  if (values.length === 1) return values[0] ?? '';
+  return `${values.slice(0, -1).join(', ')} or ${values.at(-1)}`;
+}
+
+export function isMemoryScope(value: string | undefined): value is MemoryScope {
+  return value === 'user' || value === 'local' || value === 'project';
+}
+
+export function isActiveMemoryScope(
+  value: string | undefined,
+): value is 'user' | 'local' | 'project' {
+  return value === 'user' || value === 'local' || value === 'project';
+}
+
+export function parseMemoryValue(raw: string): JsonValue {
+  try {
+    return JSON.parse(raw) as JsonValue;
+  } catch {
+    return raw;
+  }
+}
+
+export function readStringArrayProperty(
+  value: unknown,
+  key: string,
+): string[] | undefined {
+  if (!value || typeof value !== 'object' || !(key in value)) return undefined;
+  const property = (value as Record<string, unknown>)[key];
+  if (!Array.isArray(property)) return undefined;
+  return property.filter((item): item is string => typeof item === 'string');
+}
+
+export function errorMessage(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/modules/config/actions.ts

@@ -0,0 +1,253 @@
+import { defineAction } from '@flue/runtime';
+import * as v from 'valibot';
+import { executionPolicyUpdateSchema } from '../execution-policy';
+import { dashboardConfigSchema } from '../../runtime-home';
+import {
+  addRepoInputSchema,
+  configActionOutputSchema,
+  configTargetSchema,
+  dashboardPresetSchema,
+  removeRepoInputSchema,
+  updateAgentModelsInputSchema,
+  updateHandoffConfigInputSchema,
+  updateLearningConfigInputSchema,
+  updateProviderInputSchema,
+  updateRepoAutopilotPolicyInputSchema,
+  updateRepoInputSchema,
+  updateSkillRootsInputSchema,
+  updateWorktreePolicyInputSchema,
+} from './schemas';
+import { readConfig, reloadConfig, validateConfig } from './read';
+import {
+  updateDashboardLayout,
+  applyDashboardPreset,
+} from './mutations/dashboard';
+import { updateExecutionPolicy } from './mutations/execution';
+import {
+  updateAgentModels,
+  updateHandoffConfig,
+  updateLearningConfig,
+  updateSkillRoots,
+  updateWorktreePolicy,
+} from './mutations/models';
+import {
+  readProviderConfig,
+  updateProviderConfig,
+} from './mutations/providers';
+import {
+  addRepo,
+  removeRepo,
+  updateRepo,
+  updateRepoAutopilotPolicy,
+} from './mutations/repos';
+
+export const configReadAction = defineAction({
+  name: 'neondeck_config_read',
+  description:
+    'Read validated Neondeck runtime config files without mutating them.',
+  input: v.object({
+    target: configTargetSchema,
+  }),
+  output: configActionOutputSchema,
+  async run({ input }) {
+    return readConfig(input);
+  },
+});
+
+export const configValidateAction = defineAction({
+  name: 'neondeck_config_validate',
+  description:
+    'Validate Neondeck runtime config files and report schema errors.',
+  input: v.object({
+    target: configTargetSchema,
+  }),
+  output: configActionOutputSchema,
+  async run({ input }) {
+    return validateConfig(input);
+  },
+});
+
+export const configReloadAction = defineAction({
+  name: 'neondeck_config_reload',
+  description:
+    'Reload Neondeck runtime config by validating files and returning the active config snapshot.',
+  input: v.object({}),
+  output: configActionOutputSchema,
+  async run() {
+    return reloadConfig();
+  },
+});
+
+export const updateAgentModelsAction = defineAction({
+  name: 'neondeck_config_update_agent_models',
+  description:
+    'Update display-assistant, utility, self-improvement, and subagent model names in runtime config.json. Provider registration is not changed by this action.',
+  input: updateAgentModelsInputSchema,
+  output: configActionOutputSchema,
+  async run({ input }) {
+    return updateAgentModels(input);
+  },
+});
+
+export const updateSkillRootsAction = defineAction({
+  name: 'neondeck_config_update_skill_roots',
+  description:
+    'Update external runtime skill roots in config.json with schema validation and config history.',
+  input: updateSkillRootsInputSchema,
+  output: configActionOutputSchema,
+  async run({ input }) {
+    return updateSkillRoots(input);
+  },
+});
+
+export const updateLearningConfigAction = defineAction({
+  name: 'neondeck_config_update_learning',
+  description:
+    'Update Neondeck learning and memory-curation policy in runtime config.json.',
+  input: updateLearningConfigInputSchema,
+  output: configActionOutputSchema,
+  async run({ input }) {
+    return updateLearningConfig(input);
+  },
+});
+
+export const updateHandoffConfigAction = defineAction({
+  name: 'neondeck_config_update_handoff',
+  description:
+    'Update external agent handoff policy in runtime config.json, including whether external registrations may queue PR review assistance.',
+  input: updateHandoffConfigInputSchema,
+  output: configActionOutputSchema,
+  async run({ input }) {
+    return updateHandoffConfig(input);
+  },
+});
+
+export const updateWorktreePolicyAction = defineAction({
+  name: 'neondeck_config_update_worktree_policy',
+  description:
+    'Update Neondeck worktree storage default and cleanup policy in runtime config.json. Does not create or delete worktrees.',
+  input: updateWorktreePolicyInputSchema,
+  output: configActionOutputSchema,
+  async run({ input }) {
+    return updateWorktreePolicy(input);
+  },
+});
+
+export const readProvidersAction = defineAction({
+  name: 'neondeck_config_read_providers',
+  description:
+    'Read validated allowlisted provider configuration without exposing secret values.',
+  input: v.object({}),
+  output: configActionOutputSchema,
+  async run() {
+    return readProviderConfig();
+  },
+});
+
+export const updateProviderAction = defineAction({
+  name: 'neondeck_config_update_provider',
+  description:
+    'Update allowlisted provider configuration in config.json using secret environment variable references only. Does not accept raw secrets or arbitrary base URLs.',
+  input: updateProviderInputSchema,
+  output: configActionOutputSchema,
+  async run({ input }) {
+    return updateProviderConfig(input);
+  },
+});
+
+export const updateExecutionPolicyAction = defineAction({
+  name: 'neondeck_config_update_execution_policy',
+  description:
+    'Update Neondeck host execution approval policy in config.json, including preapproved local or exe.dev commands. Does not execute commands.',
+  input: executionPolicyUpdateSchema,
+  output: configActionOutputSchema,
+  async run({ input }) {
+    return updateExecutionPolicy(input);
+  },
+});
+
+export const updateDashboardLayoutAction = defineAction({
+  name: 'neondeck_config_update_dashboard_layout',
+  description:
+    'Replace dashboard.json with a validated stacked-region dashboard layout.',
+  input: dashboardConfigSchema,
+  output: configActionOutputSchema,
+  async run({ input }) {
+    return updateDashboardLayout(input);
+  },
+});
+
+export const applyDashboardPresetAction = defineAction({
+  name: 'neondeck_config_apply_dashboard_preset',
+  description:
+    'Apply a known dashboard layout preset such as classic or cockpit.',
+  input: dashboardPresetSchema,
+  output: configActionOutputSchema,
+  async run({ input }) {
+    return applyDashboardPreset(input);
+  },
+});
+
+export const addRepoAction = defineAction({
+  name: 'neondeck_config_add_repo',
+  description:
+    'Add a local git repository to Neondeck repos.json after path, git, GitHub, and schema validation.',
+  input: addRepoInputSchema,
+  output: configActionOutputSchema,
+  async run({ input }) {
+    return addRepo(input);
+  },
+});
+
+export const updateRepoAction = defineAction({
+  name: 'neondeck_config_update_repo',
+  description:
+    'Update an existing Neondeck repository entry in repos.json with schema validation.',
+  input: updateRepoInputSchema,
+  output: configActionOutputSchema,
+  async run({ input }) {
+    return updateRepo(input);
+  },
+});
+
+export const updateRepoAutopilotPolicyAction = defineAction({
+  name: 'neondeck_config_update_repo_autopilot_policy',
+  description:
+    'Update one repository’s typed autopilot policy. Explicit confirmation is required when the change increases autonomy, relaxes limits, expands push destinations, or enables force push.',
+  input: updateRepoAutopilotPolicyInputSchema,
+  output: configActionOutputSchema,
+  async run({ input }) {
+    return updateRepoAutopilotPolicy(input);
+  },
+});
+
+export const removeRepoAction = defineAction({
+  name: 'neondeck_config_remove_repo',
+  description:
+    'Remove an existing Neondeck repository entry from repos.json after explicit confirmation.',
+  input: removeRepoInputSchema,
+  output: configActionOutputSchema,
+  async run({ input }) {
+    return removeRepo(input);
+  },
+});
+
+export const neondeckConfigActions = [
+  configReadAction,
+  configValidateAction,
+  configReloadAction,
+  updateAgentModelsAction,
+  updateSkillRootsAction,
+  updateLearningConfigAction,
+  updateHandoffConfigAction,
+  updateWorktreePolicyAction,
+  readProvidersAction,
+  updateProviderAction,
+  updateExecutionPolicyAction,
+  updateDashboardLayoutAction,
+  applyDashboardPresetAction,
+  addRepoAction,
+  updateRepoAction,
+  updateRepoAutopilotPolicyAction,
+  removeRepoAction,
+];

package/src/modules/config/events.ts

@@ -0,0 +1,80 @@
+import type { RuntimePaths } from '../../runtime-home';
+
+export type ConfigChangeEvent = {
+  id: string;
+  action: string;
+  changed: boolean;
+  home: string;
+  files: string[];
+  target: string | null;
+  changedAt: string;
+};
+
+type ConfigChangeListener = (event: ConfigChangeEvent) => void;
+
+const listeners = new Set<ConfigChangeListener>();
+const recentConfigEventLimit = 100;
+const recentConfigEvents: ConfigChangeEvent[] = [];
+
+export function publishConfigEvent(event: ConfigChangeEvent) {
+  recentConfigEvents.push(event);
+  if (recentConfigEvents.length > recentConfigEventLimit) {
+    recentConfigEvents.shift();
+  }
+
+  for (const listener of listeners) {
+    listener(event);
+  }
+}
+
+export function replayConfigEventsAfter(
+  lastEventId: string | null | undefined,
+) {
+  if (!lastEventId) return [];
+
+  const eventIndex = recentConfigEvents.findIndex(
+    (event) => event.id === lastEventId,
+  );
+  if (eventIndex === -1) return recentConfigEvents.slice();
+
+  return recentConfigEvents.slice(eventIndex + 1);
+}
+
+export function subscribeConfigEvents(listener: ConfigChangeListener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+export function configEventFromChange(
+  paths: RuntimePaths,
+  change: {
+    id?: string | number | bigint;
+    action: string;
+    changed: boolean;
+    files: string[];
+    target?: string | null;
+    changedAt: string;
+  },
+): ConfigChangeEvent {
+  return {
+    id: String(change.id ?? `${change.changedAt}:${change.action}`),
+    action: change.action,
+    changed: change.changed,
+    home: paths.home,
+    files: change.files,
+    target: change.target ?? null,
+    changedAt: change.changedAt,
+  };
+}
+
+export function formatConfigServerSentEvent(event: ConfigChangeEvent) {
+  return [
+    `id: ${event.id}`,
+    'event: config-change',
+    `data: ${JSON.stringify(event)}`,
+    '',
+    '',
+  ].join('\n');
+}

package/src/modules/config/files.ts

@@ -0,0 +1,9 @@
+import { mkdir, rename, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+
+export async function writeJson(path: string, value: unknown) {
+  await mkdir(dirname(path), { recursive: true });
+  const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+  await rename(tempPath, path);
+}