neondeck 1.0.0-beta.10

package/src/runtime-home/bootstrap.ts

@@ -0,0 +1,177 @@
+import { existsSync, mkdirSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import {
+  initializeAppDatabase,
+  initializeFlueDatabase,
+} from './app-db/index.ts';
+import { defaultAppConfig } from './defaults.ts';
+import { defaultMcpConfig } from '../domains/mcp/schemas.ts';
+import {
+  migrateDashboardConfig,
+  migrateDashboardConfigSync,
+} from './dashboard-migrations.ts';
+import {
+  copyIfMissing,
+  copyIfMissingSync,
+  ensureLocalApiConfig,
+  ensureLocalApiConfigSync,
+  writeFileIfMissing,
+  writeFileIfMissingSync,
+  writeJsonIfMissing,
+  writeJsonIfMissingSync,
+} from './files.ts';
+import {
+  defaultDashboardPath,
+  defaultDashboardSchemaPath,
+  defaultSoulPath,
+  runtimePaths,
+} from './paths.ts';
+
+const seededRuntimeSkills = [
+  {
+    id: 'neon-pr-review',
+    source: fileURLToPath(
+      new URL('../skills/neon-pr-review/SKILL.md', import.meta.url),
+    ),
+  },
+  {
+    id: 'neon-ci-fix',
+    source: fileURLToPath(
+      new URL('../skills/neon-ci-fix/SKILL.md', import.meta.url),
+    ),
+  },
+  {
+    id: 'neon-docs-fix',
+    source: fileURLToPath(
+      new URL('../skills/neon-docs-fix/SKILL.md', import.meta.url),
+    ),
+  },
+  {
+    id: 'neon-issue-triage',
+    source: fileURLToPath(
+      new URL('../skills/neon-issue-triage/SKILL.md', import.meta.url),
+    ),
+  },
+];
+
+const initializedRuntimeDatabases = new Set<string>();
+const pendingRuntimeHomeInitializations = new Map<string, Promise<void>>();
+const pendingRuntimeDatabaseInitializations = new Map<string, Promise<void>>();
+
+export async function ensureRuntimeHome(paths = runtimePaths()) {
+  const key = resolve(paths.home);
+  const pending = pendingRuntimeHomeInitializations.get(key);
+  if (pending) {
+    await pending;
+    return;
+  }
+
+  const initialization = initializeRuntimeHome(paths).finally(() => {
+    if (pendingRuntimeHomeInitializations.get(key) === initialization) {
+      pendingRuntimeHomeInitializations.delete(key);
+    }
+  });
+  pendingRuntimeHomeInitializations.set(key, initialization);
+  await initialization;
+}
+
+async function initializeRuntimeHome(paths = runtimePaths()) {
+  await mkdir(paths.home, { recursive: true });
+  await mkdir(paths.data, { recursive: true });
+  await mkdir(paths.skills, { recursive: true });
+  await mkdir(paths.worktrees, { recursive: true });
+
+  await writeFileIfMissing(paths.env, '');
+  await writeJsonIfMissing(paths.config, defaultAppConfig());
+  await ensureLocalApiConfig(paths.config);
+  await writeJsonIfMissing(paths.mcp, defaultMcpConfig());
+  await writeJsonIfMissing(paths.repos, { repos: [] });
+  await copyIfMissing(defaultDashboardPath, paths.dashboard);
+  await migrateDashboardConfig(paths.dashboard);
+  await copyIfMissing(defaultDashboardSchemaPath, paths.dashboardSchema);
+  await copyIfMissing(defaultSoulPath, paths.soul);
+  await seedRuntimeSkills(paths);
+  await ensureRuntimeDatabases(paths);
+}
+
+export function ensureRuntimeHomeSync(paths = runtimePaths()) {
+  mkdirSync(paths.home, { recursive: true });
+  mkdirSync(paths.data, { recursive: true });
+  mkdirSync(paths.skills, { recursive: true });
+  mkdirSync(paths.worktrees, { recursive: true });
+
+  writeFileIfMissingSync(paths.env, '');
+  writeJsonIfMissingSync(paths.config, defaultAppConfig());
+  ensureLocalApiConfigSync(paths.config);
+  writeJsonIfMissingSync(paths.mcp, defaultMcpConfig());
+  writeJsonIfMissingSync(paths.repos, { repos: [] });
+  copyIfMissingSync(defaultDashboardPath, paths.dashboard);
+  migrateDashboardConfigSync(paths.dashboard);
+  copyIfMissingSync(defaultDashboardSchemaPath, paths.dashboardSchema);
+  copyIfMissingSync(defaultSoulPath, paths.soul);
+  seedRuntimeSkillsSync(paths);
+  ensureRuntimeDatabasesSync(paths);
+}
+
+async function ensureRuntimeDatabases(paths = runtimePaths()) {
+  const key = runtimeDatabaseKey(paths);
+  if (runtimeDatabasesAreInitialized(key, paths)) return;
+
+  const pending = pendingRuntimeDatabaseInitializations.get(key);
+  if (pending) {
+    await pending;
+    return;
+  }
+
+  const initialization = Promise.resolve()
+    .then(() => {
+      initializeRuntimeDatabases(paths);
+      initializedRuntimeDatabases.add(key);
+    })
+    .finally(() => {
+      pendingRuntimeDatabaseInitializations.delete(key);
+    });
+  pendingRuntimeDatabaseInitializations.set(key, initialization);
+  await initialization;
+}
+
+function ensureRuntimeDatabasesSync(paths = runtimePaths()) {
+  const key = runtimeDatabaseKey(paths);
+  if (runtimeDatabasesAreInitialized(key, paths)) return;
+  initializeRuntimeDatabases(paths);
+  initializedRuntimeDatabases.add(key);
+}
+
+function initializeRuntimeDatabases(paths = runtimePaths()) {
+  initializeAppDatabase(paths.neondeckDatabase);
+  initializeFlueDatabase(paths.flueDatabase);
+}
+
+async function seedRuntimeSkills(paths = runtimePaths()) {
+  await Promise.all(
+    seededRuntimeSkills.map((skill) =>
+      copyIfMissing(skill.source, join(paths.skills, skill.id, 'SKILL.md')),
+    ),
+  );
+}
+
+function seedRuntimeSkillsSync(paths = runtimePaths()) {
+  for (const skill of seededRuntimeSkills) {
+    copyIfMissingSync(skill.source, join(paths.skills, skill.id, 'SKILL.md'));
+  }
+}
+
+function runtimeDatabaseKey(paths = runtimePaths()) {
+  return `${resolve(paths.neondeckDatabase)}\0${resolve(paths.flueDatabase)}`;
+}
+
+function runtimeDatabasesAreInitialized(key: string, paths = runtimePaths()) {
+  return (
+    initializedRuntimeDatabases.has(key) &&
+    existsSync(paths.neondeckDatabase) &&
+    existsSync(paths.flueDatabase)
+  );
+}

package/src/runtime-home/dashboard-migrations.ts

@@ -0,0 +1,101 @@
+import {
+  isRecord,
+  readJsonObjectLenient,
+  readJsonObjectLenientSync,
+  writeJsonAtomic,
+  writeJsonAtomicSync,
+} from './files.ts';
+
+export const dashboardSchemaVersion = 1;
+
+const reviewsTab = {
+  id: 'reviews',
+  title: 'REVIEWS',
+  pluginId: 'reviews-panel',
+  config: {},
+};
+
+export async function migrateDashboardConfig(path: string) {
+  const current = await readJsonObjectLenient(path);
+  const migrated = migrateDashboardConfigValue(current);
+  if (migrated) await writeJsonAtomic(path, migrated);
+}
+
+export function migrateDashboardConfigSync(path: string) {
+  const current = readJsonObjectLenientSync(path);
+  const migrated = migrateDashboardConfigValue(current);
+  if (migrated) writeJsonAtomicSync(path, migrated);
+}
+
+export function migrateDashboardConfigValue(
+  current: Record<string, unknown> | null,
+) {
+  if (!current) return null;
+  const version =
+    typeof current.schemaVersion === 'number' &&
+    Number.isInteger(current.schemaVersion)
+      ? current.schemaVersion
+      : 0;
+  if (version >= dashboardSchemaVersion) return null;
+
+  const layout = isRecord(current.layout) ? current.layout : null;
+  const regions = Array.isArray(layout?.regions) ? layout.regions : null;
+  const hasReviews = regions?.some(
+    (region) =>
+      isRecord(region) &&
+      Array.isArray(region.tabs) &&
+      region.tabs.some(
+        (tab) =>
+          isRecord(tab) &&
+          (tab.id === reviewsTab.id || tab.pluginId === reviewsTab.pluginId),
+      ),
+  );
+  const workRegionIndex = regions?.findIndex(
+    (region) =>
+      isRecord(region) &&
+      (region.id === 'work' ||
+        (Array.isArray(region.tabs) &&
+          region.tabs.some(
+            (tab) => isRecord(tab) && tab.pluginId === 'github-pr-list',
+          ))),
+  );
+  const fallbackRegionIndex = regions?.findIndex(
+    (region) => isRecord(region) && Array.isArray(region.tabs),
+  );
+  const targetRegionIndex =
+    workRegionIndex !== undefined && workRegionIndex >= 0
+      ? workRegionIndex
+      : fallbackRegionIndex;
+
+  let nextLayout = layout;
+  if (
+    !hasReviews &&
+    regions &&
+    targetRegionIndex !== undefined &&
+    targetRegionIndex >= 0
+  ) {
+    const targetRegion = regions[targetRegionIndex];
+    if (isRecord(targetRegion) && Array.isArray(targetRegion.tabs)) {
+      const tabs = [...targetRegion.tabs];
+      const githubIndex = tabs.findIndex(
+        (tab) => isRecord(tab) && tab.pluginId === 'github-pr-list',
+      );
+      const insertIndex =
+        workRegionIndex !== undefined && workRegionIndex >= 0
+          ? githubIndex >= 0
+            ? githubIndex + 1
+            : 0
+          : tabs.length;
+      tabs.splice(insertIndex, 0, reviewsTab);
+      const nextRegions = [...regions];
+      nextRegions[targetRegionIndex] = { ...targetRegion, tabs };
+      nextLayout = { ...layout, regions: nextRegions };
+    }
+  }
+
+  return {
+    ...current,
+    schemaVersion: dashboardSchemaVersion,
+    ...(nextLayout ? { layout: nextLayout } : {}),
+  };
+}

package/src/runtime-home/defaults.ts

@@ -0,0 +1,54 @@
+import { randomBytes } from 'node:crypto';
+
+import type { AppConfig, ResolvedLearningConfig } from './schemas.ts';
+
+export function defaultAppConfig(): AppConfig {
+  return {
+    version: 1,
+    localApi: { token: generateLocalApiToken() },
+    guardrails: {
+      deniedFileGlobs: [],
+      approvalRequiredFileGlobs: [],
+      highRiskClasses: [],
+      maxFilesChanged: 50,
+      maxLinesChanged: 1_500,
+      allowForcePush: false,
+      allowedPushDestinations: ['pull-request-head'],
+      requiredChecks: [],
+    },
+    autopilot: {
+      mode: 'notify-only',
+      concurrency: { singleMutationPerPr: true },
+      pushOnApproval: 'verify-then-push',
+    },
+  };
+}
+
+export function generateLocalApiToken() {
+  return randomBytes(32).toString('base64url');
+}
+
+export function resolveLearningConfig(
+  config?: Pick<AppConfig, 'learning'>,
+): ResolvedLearningConfig {
+  const learning = config?.learning ?? {};
+  return {
+    enabled: learning.enabled ?? true,
+    memoryWriteMode: learning.memoryWriteMode ?? 'auto',
+    skillWriteMode: learning.skillWriteMode ?? 'auto',
+    memoryCurationEnabled: learning.memoryCurationEnabled ?? true,
+    memoryCurationMode: learning.memoryCurationMode ?? 'review',
+    conversationReviewTurnInterval:
+      learning.conversationReviewTurnInterval ?? 10,
+    memoryCurationTurnInterval: learning.memoryCurationTurnInterval ?? 200,
+    prRetrospectiveThreshold: learning.prRetrospectiveThreshold ?? 5,
+    notifications: learning.notifications ?? 'on',
+    memoryMaxActiveItems: learning.memoryMaxActiveItems ?? 200,
+    maxRecentTurns: learning.maxRecentTurns ?? 30,
+    maxPrBatchItems: learning.maxPrBatchItems ?? 8,
+    memoryPromptBudgetChars: learning.memoryPromptBudgetChars ?? 3500,
+    userMemoryBudgetChars: learning.userMemoryBudgetChars ?? 1000,
+    localMemoryBudgetChars: learning.localMemoryBudgetChars ?? 1000,
+    projectMemoryBudgetChars: learning.projectMemoryBudgetChars ?? 1500,
+  };
+}

package/src/runtime-home/files.ts

@@ -0,0 +1,193 @@
+import {
+  constants,
+  copyFileSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync,
+} from 'node:fs';
+import { copyFile, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { randomBytes } from 'node:crypto';
+import { dirname } from 'node:path';
+
+import { generateLocalApiToken } from './defaults.ts';
+import { runtimePaths } from './paths.ts';
+import {
+  ConfigValidationError,
+  parseAppConfig,
+  parseDashboardConfig,
+  parseMcpConfig,
+  parseRepoRegistry,
+} from './schemas.ts';
+
+export async function readRuntimeJson<T>(
+  path: string,
+  parse: (value: unknown, path: string) => T,
+): Promise<T> {
+  const source = await readFile(path, 'utf8');
+  return parseJson(source, path, parse);
+}
+
+export function readRuntimeJsonSync<T>(
+  path: string,
+  parse: (value: unknown, path: string) => T,
+): T {
+  const source = readFileSync(path, 'utf8');
+  return parseJson(source, path, parse);
+}
+
+export async function validateRuntimeFiles(paths = runtimePaths()) {
+  await readRuntimeJson(paths.config, parseAppConfig);
+  await readRuntimeJson(paths.mcp, parseMcpConfig);
+  await readRuntimeJson(paths.repos, parseRepoRegistry);
+  await readRuntimeJson(paths.dashboard, parseDashboardConfig);
+}
+
+export function validateRuntimeFilesSync(paths = runtimePaths()) {
+  readRuntimeJsonSync(paths.config, parseAppConfig);
+  readRuntimeJsonSync(paths.mcp, parseMcpConfig);
+  readRuntimeJsonSync(paths.repos, parseRepoRegistry);
+  readRuntimeJsonSync(paths.dashboard, parseDashboardConfig);
+}
+
+export async function ensureLocalApiConfig(path: string) {
+  const value = await readJsonObjectLenient(path);
+  if (!value) return;
+  if (isValidLocalApiToken(readLocalApiTokenValue(value))) return;
+
+  await writeJsonAtomic(path, {
+    ...value,
+    localApi: { token: generateLocalApiToken() },
+  });
+}
+
+export function ensureLocalApiConfigSync(path: string) {
+  const value = readJsonObjectLenientSync(path);
+  if (!value) return;
+  if (isValidLocalApiToken(readLocalApiTokenValue(value))) return;
+
+  writeJsonAtomicSync(path, {
+    ...value,
+    localApi: { token: generateLocalApiToken() },
+  });
+}
+
+export async function readJsonObjectLenient(path: string) {
+  try {
+    const value = JSON.parse(await readFile(path, 'utf8')) as unknown;
+    return isRecord(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+export function readJsonObjectLenientSync(path: string) {
+  try {
+    const value = JSON.parse(readFileSync(path, 'utf8')) as unknown;
+    return isRecord(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+function readLocalApiTokenValue(value: Record<string, unknown>) {
+  const localApi = value.localApi;
+  if (!isRecord(localApi)) return undefined;
+  return localApi.token;
+}
+
+function isValidLocalApiToken(value: unknown) {
+  return typeof value === 'string' && /^[A-Za-z0-9_-]{32,}$/.test(value);
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+export async function writeJsonAtomic(path: string, value: unknown) {
+  await mkdir(dirname(path), { recursive: true });
+  const tempPath = temporaryJsonPath(path);
+  await writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+  await rename(tempPath, path);
+}
+
+export function writeJsonAtomicSync(path: string, value: unknown) {
+  mkdirSync(dirname(path), { recursive: true });
+  const tempPath = temporaryJsonPath(path);
+  writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+  renameSync(tempPath, path);
+}
+
+function temporaryJsonPath(path: string) {
+  return `${path}.${process.pid}.${randomBytes(8).toString('hex')}.tmp`;
+}
+
+export async function writeJsonIfMissing(path: string, value: unknown) {
+  await writeFileIfMissing(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+export function writeJsonIfMissingSync(path: string, value: unknown) {
+  writeFileIfMissingSync(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+export async function writeFileIfMissing(path: string, value: string) {
+  await mkdir(dirname(path), { recursive: true });
+  try {
+    await writeFile(path, value, { encoding: 'utf8', flag: 'wx' });
+  } catch (error) {
+    if (!isAlreadyExistsError(error)) throw error;
+  }
+}
+
+export function writeFileIfMissingSync(path: string, value: string) {
+  mkdirSync(dirname(path), { recursive: true });
+  try {
+    writeFileSync(path, value, { encoding: 'utf8', flag: 'wx' });
+  } catch (error) {
+    if (!isAlreadyExistsError(error)) throw error;
+  }
+}
+
+export async function copyIfMissing(source: string, target: string) {
+  await mkdir(dirname(target), { recursive: true });
+  try {
+    await copyFile(source, target, constants.COPYFILE_EXCL);
+  } catch (error) {
+    if (!isAlreadyExistsError(error)) throw error;
+  }
+}
+
+export function copyIfMissingSync(source: string, target: string) {
+  mkdirSync(dirname(target), { recursive: true });
+  try {
+    copyFileSync(source, target, constants.COPYFILE_EXCL);
+  } catch (error) {
+    if (!isAlreadyExistsError(error)) throw error;
+  }
+}
+
+function isAlreadyExistsError(error: unknown) {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'code' in error &&
+    error.code === 'EEXIST'
+  );
+}
+
+function parseJson<T>(
+  source: string,
+  path: string,
+  parse: (value: unknown, path: string) => T,
+) {
+  try {
+    return parse(JSON.parse(source) as unknown, path);
+  } catch (error) {
+    if (error instanceof ConfigValidationError) {
+      throw error;
+    }
+
+    const message = error instanceof Error ? error.message : String(error);
+    throw new ConfigValidationError(path, message);
+  }
+}

package/src/runtime-home/guardrails.ts

@@ -0,0 +1,77 @@
+import * as v from 'valibot';
+
+const nonEmptyStringSchema = v.pipe(v.string(), v.minLength(1));
+
+export type RepoGuardrails = {
+  maxFilesChanged: number;
+  maxLinesChanged: number;
+  deniedFileGlobs: string[];
+  approvalRequiredFileGlobs: string[];
+  requiredChecks: string[];
+  allowedPushDestinations: string[];
+  allowForcePush: boolean;
+  highRiskClasses: string[];
+  generatedFileSizeThresholdBytes: number;
+};
+
+export type RepoGuardrailsConfig = Partial<RepoGuardrails>;
+
+export const repoGuardrailsSchema = v.looseObject({
+  maxFilesChanged: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1))),
+  maxLinesChanged: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1))),
+  deniedFileGlobs: v.optional(v.array(nonEmptyStringSchema)),
+  approvalRequiredFileGlobs: v.optional(v.array(nonEmptyStringSchema)),
+  requiredChecks: v.optional(v.array(nonEmptyStringSchema)),
+  allowedPushDestinations: v.optional(v.array(nonEmptyStringSchema)),
+  allowForcePush: v.optional(v.boolean()),
+  highRiskClasses: v.optional(v.array(nonEmptyStringSchema)),
+  generatedFileSizeThresholdBytes: v.optional(
+    v.pipe(v.number(), v.integer(), v.minValue(1)),
+  ),
+});
+
+export const defaultRepoGuardrails: RepoGuardrails = {
+  maxFilesChanged: 12,
+  maxLinesChanged: 500,
+  deniedFileGlobs: [
+    '.git/**',
+    '.env*',
+    '**/.env*',
+    '*.{pem,key,p12,pfx}',
+    '**/*.{pem,key,p12,pfx}',
+    '**/*secret*',
+  ],
+  approvalRequiredFileGlobs: [
+    '**/package-lock.json',
+    '**/pnpm-lock.yaml',
+    '**/yarn.lock',
+    '**/bun.lock',
+    '**/Cargo.lock',
+    '**/package.json',
+    '.github/**',
+    '.gitlab-ci.yml',
+    '**/migrations/**',
+    '**/*.{png,jpg,jpeg,gif,webp,zip}',
+    'vendor/**',
+    '**/vendor/**',
+    'third_party/**',
+    '**/third_party/**',
+  ],
+  requiredChecks: [],
+  allowedPushDestinations: ['pull-request-head'],
+  allowForcePush: false,
+  highRiskClasses: [
+    'lockfile',
+    'dependency-manifest',
+    'ci-config',
+    'deployment-config',
+    'security-sensitive-code',
+    'secrets-env',
+    'database-migration',
+    'large-generated-file',
+    'binary-file',
+    'vendored-code',
+    'repo-glob',
+  ],
+  generatedFileSizeThresholdBytes: 256 * 1024,
+};

package/src/runtime-home/index.ts

@@ -0,0 +1,71 @@
+export { generateLocalApiToken, resolveLearningConfig } from './defaults.ts';
+export {
+  defaultRepoGuardrails,
+  repoGuardrailsSchema,
+  type RepoGuardrails,
+  type RepoGuardrailsConfig,
+} from './guardrails.ts';
+export { ensureRuntimeHome, ensureRuntimeHomeSync } from './bootstrap.ts';
+export { dashboardSchemaVersion } from './dashboard-migrations.ts';
+export {
+  readRuntimeJson,
+  readRuntimeJsonSync,
+  validateRuntimeFiles,
+  validateRuntimeFilesSync,
+} from './files.ts';
+export {
+  type RuntimeHomeEnv,
+  type RuntimePaths,
+  resolveRuntimeHome,
+  runtimePaths,
+} from './paths.ts';
+export {
+  agentModelConfigSchema,
+  appConfigSchema,
+  autopilotConcurrencySchema,
+  autopilotConfigSchema,
+  autopilotModeSchema,
+  ConfigValidationError,
+  dashboardConfigSchema,
+  dashboardRegionSchema,
+  dashboardTabSchema,
+  executionConfigSchema,
+  executionPreapprovedCommandSchema,
+  handoffConfigSchema,
+  kiloConfigSchema,
+  learningConfigSchema,
+  localApiConfigSchema,
+  localApiTokenSchema,
+  parseAppConfig,
+  parseDashboardConfig,
+  parseRepoRegistry,
+  providerConfigSchema,
+  repoConfigSchema,
+  repoRegistrySchema,
+  thinkingLevelSchema,
+  worktreeCleanupConfigSchema,
+  worktreeConfigSchema,
+  type AgentModelConfig,
+  type AppConfig,
+  type AutopilotConfig,
+  type DashboardConfig,
+  type DashboardRegion,
+  type DashboardTab,
+  type DashboardWindowProfile,
+  type ExecutionBackend,
+  type ExecutionConfig,
+  type ExecutionPreapprovedCommand,
+  type ExeDevCheckoutConfig,
+  type ExeDevEnvForwardingConfig,
+  type HandoffConfig,
+  type KiloConfig,
+  type LearningConfig,
+  type LocalApiConfig,
+  type ProviderConfig,
+  type RepoConfig,
+  type RepoRegistry,
+  type ResolvedLearningConfig,
+  type ThinkingLevel,
+  type WorktreeCleanupConfig,
+  type WorktreeConfig,
+} from './schemas.ts';