@bastani/atomic 0.5.0-1

package/src/services/config/definitions.ts

@@ -0,0 +1,176 @@
+/**
+ * Agent configuration definitions for atomic CLI
+ */
+
+export interface AgentConfig {
+  /** Display name for the agent */
+  name: string;
+  /** Command to execute the agent */
+  cmd: string;
+  /** Flags used when spawning the agent in interactive chat mode */
+  chat_flags: string[];
+  /** Config folder relative to repo root */
+  folder: string;
+  /** URL for installation instructions */
+  install_url: string;
+  /** Paths to exclude when copying (relative to folder) */
+  exclude: string[];
+  /** Project files managed by `atomic init` for provider onboarding */
+  onboarding_files: Array<{
+    source: string;
+    destination: string;
+    merge: boolean;
+  }>;
+}
+
+const AGENT_KEYS = ["claude", "opencode", "copilot"] as const;
+export type AgentKey = (typeof AGENT_KEYS)[number];
+
+export const AGENT_CONFIG: Record<AgentKey, AgentConfig> = {
+  claude: {
+    name: "Claude Code",
+    cmd: "claude",
+    chat_flags: ["--allow-dangerously-skip-permissions", "--dangerously-skip-permissions"],
+    folder: ".claude",
+    install_url: "https://code.claude.com/docs/en/setup",
+    exclude: [".DS_Store", "settings.json"],
+    onboarding_files: [
+      {
+        source: ".mcp.json",
+        destination: ".mcp.json",
+        merge: true,
+      },
+      {
+        source: ".claude/settings.json",
+        destination: ".claude/settings.json",
+        merge: true,
+      },
+    ],
+  },
+  opencode: {
+    name: "OpenCode",
+    cmd: "opencode",
+    chat_flags: [],
+    folder: ".opencode",
+    install_url: "https://opencode.ai",
+    exclude: [
+      "node_modules",
+      ".gitignore",
+      "bun.lock",
+      "package.json",
+      ".DS_Store",
+      "opencode.json",
+    ],
+    onboarding_files: [
+      {
+        source: ".opencode/opencode.json",
+        destination: ".opencode/opencode.json",
+        merge: true,
+      },
+    ],
+  },
+  copilot: {
+    name: "GitHub Copilot CLI",
+    cmd: "copilot",
+    chat_flags: ["--add-dir", ".", "--yolo", "--experimental"],
+    folder: ".github",
+    install_url:
+      "https://github.com/github/copilot-cli?tab=readme-ov-file#installation",
+    exclude: ["workflows", "dependabot.yml", ".DS_Store"],
+    onboarding_files: [
+      {
+        source: ".vscode/mcp.json",
+        destination: ".vscode/mcp.json",
+        merge: true,
+      },
+    ],
+  },
+};
+
+export function isValidAgent(key: string): key is AgentKey {
+  return key in AGENT_CONFIG;
+}
+
+export function getAgentConfig(key: AgentKey): AgentConfig {
+  return AGENT_CONFIG[key];
+}
+
+export function getAgentKeys(): AgentKey[] {
+  return [...AGENT_KEYS];
+}
+
+/**
+ * Source Control Management (SCM) configuration definitions
+ */
+
+/** Supported source control types */
+export type SourceControlType = "github" | "sapling";
+// Future: | 'azure-devops'
+
+/** SCM keys for iteration */
+const SCM_KEYS = ["github", "sapling"] as const;
+
+export interface ScmConfig {
+  /** Internal identifier */
+  name: string;
+  /** Display name for prompts */
+  displayName: string;
+  /** Primary CLI tool (git or sl) */
+  cliTool: string;
+  /** Code review tool (gh, jf submit, arc diff, etc.) */
+  reviewTool: string;
+  /** Code review system (github, phabricator) */
+  reviewSystem: string;
+  /** Directory marker for potential future auto-detection */
+  detectDir: string;
+  /** Code review command file name */
+  reviewCommandFile: string;
+  /** Required configuration files */
+  requiredConfigFiles?: string[];
+}
+
+export const SCM_CONFIG: Record<SourceControlType, ScmConfig> = {
+  github: {
+    name: "github",
+    displayName: "GitHub / Git",
+    cliTool: "git",
+    reviewTool: "gh",
+    reviewSystem: "github",
+    detectDir: ".git",
+    reviewCommandFile: "create-gh-pr.md",
+  },
+  sapling: {
+    name: "sapling",
+    displayName: "Sapling + Phabricator",
+    cliTool: "sl",
+    reviewTool: "jf submit",
+    reviewSystem: "phabricator",
+    detectDir: ".sl",
+    reviewCommandFile: "submit-diff.md",
+    requiredConfigFiles: [".arcconfig", "~/.arcrc"],
+  },
+};
+
+/** Commands that have SCM-specific variants */
+export const SCM_SPECIFIC_COMMANDS = ["commit"];
+
+/**
+ * Get all SCM keys for iteration
+ */
+export function getScmKeys(): SourceControlType[] {
+  return [...SCM_KEYS];
+}
+
+/**
+ * Check if a string is a valid SCM type
+ */
+export function isValidScm(key: string): key is SourceControlType {
+  return key in SCM_CONFIG;
+}
+
+/**
+ * Get the configuration for a specific SCM type
+ */
+export function getScmConfig(key: SourceControlType): ScmConfig {
+  return SCM_CONFIG[key];
+}

package/src/services/config/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Configuration Module Exports
+ *
+ * Centralized access to the CLI's agent and SCM configuration.
+ */
+
+export * from "@/services/config/definitions.ts";

package/src/services/config/settings-schema.ts

@@ -0,0 +1,2 @@
+export const SETTINGS_SCHEMA_URL =
+  "https://raw.githubusercontent.com/flora131/atomic/main/assets/settings.schema.json";

package/src/services/config/settings.ts

@@ -0,0 +1,149 @@
+/**
+ * User settings persistence
+ *
+ * Stores user settings (e.g., model selection) across sessions.
+ * Settings are resolved in priority order:
+ *   1. .atomic/settings.json   (project-local, higher priority)
+ *   2. ~/.atomic/settings.json (global, lower priority)
+ *
+ * The --model CLI flag takes precedence over both (handled at call site).
+ */
+
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join, dirname, resolve } from "node:path";
+import { homedir } from "node:os";
+import { SETTINGS_SCHEMA_URL } from "@/services/config/settings-schema.ts";
+import { ensureDirSync } from "@/services/system/copy.ts";
+import type { AgentKey } from "@/services/config/definitions.ts";
+
+export interface TrustedPathEntry {
+  workspacePath: string;
+  provider: AgentKey;
+}
+
+interface AtomicSettings {
+  $schema?: string;
+  scm?: "github" | "sapling";
+  version?: number;
+  lastUpdated?: string;
+  prerelease?: boolean;
+  trustedPaths?: TrustedPathEntry[];
+}
+
+/** Global settings path: ~/.atomic/settings.json */
+function globalSettingsPath(): string {
+  const home = process.env.ATOMIC_SETTINGS_HOME ?? homedir();
+  return join(home, ".atomic", "settings.json");
+}
+
+/** Local settings path: {cwd}/.atomic/settings.json (CWD-scoped by design) */
+function localSettingsPath(): string {
+  const cwd = process.env.ATOMIC_SETTINGS_CWD ?? process.cwd();
+  return join(cwd, ".atomic", "settings.json");
+}
+
+function loadSettingsFileSync(path: string): AtomicSettings {
+  try {
+    if (existsSync(path)) {
+      return JSON.parse(readFileSync(path, "utf-8")) as AtomicSettings;
+    }
+  } catch {
+    // Silently fail
+  }
+  return {};
+}
+
+async function loadSettingsFile(path: string): Promise<AtomicSettings> {
+  try {
+    return await Bun.file(path).json() as AtomicSettings;
+  } catch {
+    // Silently fail (file doesn't exist or invalid JSON)
+  }
+  return {};
+}
+
+function writeGlobalSettingsSync(settings: AtomicSettings): void {
+  const path = globalSettingsPath();
+  const dir = dirname(path);
+  if (!existsSync(dir)) ensureDirSync(dir);
+  writeFileSync(path, JSON.stringify(settings, null, 2), "utf-8");
+}
+
+function normalizeTrustedPathEntry(entry: TrustedPathEntry): TrustedPathEntry {
+  return {
+    workspacePath: resolve(entry.workspacePath),
+    provider: entry.provider,
+  };
+}
+
+function normalizeTrustedPaths(entries: TrustedPathEntry[] | undefined): TrustedPathEntry[] {
+  const deduped = new Map<string, TrustedPathEntry>();
+
+  for (const entry of entries ?? []) {
+    if (
+      typeof entry.workspacePath !== "string" ||
+      typeof entry.provider !== "string"
+    ) {
+      continue;
+    }
+
+    const normalizedEntry = normalizeTrustedPathEntry(entry);
+    deduped.set(
+      `${normalizedEntry.provider}:${normalizedEntry.workspacePath}`,
+      normalizedEntry,
+    );
+  }
+
+  return Array.from(deduped.values());
+}
+
+/**
+ * Get the prerelease channel preference.
+ * Only checks global settings (~/.atomic/settings.json) since this is an install-level setting.
+ */
+export function getPrereleasePreference(): boolean {
+  return loadSettingsFileSync(globalSettingsPath()).prerelease === true;
+}
+
+export async function isTrustedWorkspacePath(
+  workspacePath: string,
+  provider: AgentKey,
+): Promise<boolean> {
+  const settings = await loadSettingsFile(globalSettingsPath());
+  const normalizedWorkspacePath = resolve(workspacePath);
+
+  return normalizeTrustedPaths(settings.trustedPaths).some((entry) =>
+    entry.provider === provider && entry.workspacePath === normalizedWorkspacePath
+  );
+}
+
+export function upsertTrustedWorkspacePath(
+  workspacePath: string,
+  provider: AgentKey,
+): void {
+  try {
+    const settings = loadSettingsFileSync(globalSettingsPath());
+    settings.$schema = SETTINGS_SCHEMA_URL;
+    settings.trustedPaths = normalizeTrustedPaths([
+      ...(settings.trustedPaths ?? []),
+      { workspacePath, provider },
+    ]);
+    writeGlobalSettingsSync(settings);
+  } catch {
+    // Silently fail
+  }
+}
+
+/**
+ * Set telemetry enabled/disabled in global settings.
+ */
+export function setTelemetryEnabled(enabled: boolean): void {
+  try {
+    const settings = loadSettingsFileSync(globalSettingsPath());
+    settings.$schema = SETTINGS_SCHEMA_URL;
+    (settings as Record<string, unknown>).telemetryEnabled = enabled;
+    writeGlobalSettingsSync(settings);
+  } catch {
+    // Silently fail
+  }
+}

package/src/services/system/copy.ts

@@ -0,0 +1,381 @@
+/**
+ * Utilities for copying directories and files with exclusions
+ */
+
+import { readdir, mkdir, stat, readFile } from "fs/promises";
+import { mkdirSync } from "fs";
+import { join, extname, relative, resolve } from "path";
+
+/**
+ * Safely create a directory (and parents) without throwing on EEXIST.
+ *
+ * `mkdir` with `{ recursive: true }` is supposed to be idempotent, but
+ * cloud-sync tools like OneDrive can create the directory between the
+ * internal existence check and the actual syscall, causing a spurious
+ * EEXIST error on Windows.  This wrapper absorbs that race.
+ */
+export async function ensureDir(path: string): Promise<void> {
+  try {
+    await mkdir(path, { recursive: true });
+  } catch (error: unknown) {
+    if (
+      error instanceof Error &&
+      "code" in error &&
+      (error as NodeJS.ErrnoException).code === "EEXIST"
+    ) {
+      return;
+    }
+    throw error;
+  }
+}
+
+/**
+ * Synchronous version of {@link ensureDir}.
+ */
+export function ensureDirSync(path: string): void {
+  try {
+    mkdirSync(path, { recursive: true });
+  } catch (error: unknown) {
+    if (
+      error instanceof Error &&
+      "code" in error &&
+      (error as NodeJS.ErrnoException).code === "EEXIST"
+    ) {
+      return;
+    }
+    throw error;
+  }
+}
+import { getOppositeScriptExtension } from "@/services/system/detect.ts";
+import {
+  assertPathWithinRoot,
+  assertRealPathWithinRoot,
+  isPathWithinRoot,
+} from "@/lib/path-root-guard.ts";
+
+/**
+ * Normalize a path for cross-platform comparison.
+ * Converts Windows backslashes to forward slashes so that exclusion
+ * patterns work consistently on both Windows and Unix systems.
+ *
+ * @param p - The path to normalize
+ * @returns The path with all backslashes converted to forward slashes
+ */
+export function normalizePath(p: string): string {
+  return p.replace(/\\/g, "/");
+}
+
+/**
+ * Check if a target path is safe (doesn't escape the base directory)
+ * Protects against path traversal attacks
+ */
+export function isPathSafe(basePath: string, targetPath: string): boolean {
+  const resolvedTarget = resolve(basePath, targetPath);
+  return isPathWithinRoot(basePath, resolvedTarget);
+}
+
+interface CopyOptions {
+  /** Paths to exclude (relative to source root or base names) */
+  exclude?: string[];
+  /** Whether to skip scripts for the opposite platform */
+  skipOppositeScripts?: boolean;
+}
+
+/**
+ * Copy a single file using Bun's file API
+ * @throws Error if the copy operation fails
+ */
+export async function copyFile(src: string, dest: string): Promise<void> {
+  if (resolve(src) === resolve(dest)) {
+    return;
+  }
+
+  try {
+    const srcFile = Bun.file(src);
+    await Bun.write(dest, srcFile);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to copy ${src} to ${dest}: ${message}`);
+  }
+}
+
+/**
+ * Copy a symlink by dereferencing it (copying the target content as a regular file)
+ * This ensures symlinks work on Windows without requiring special permissions
+ * @throws Error if the copy operation fails
+ */
+async function copySymlinkAsFile(
+  src: string,
+  dest: string,
+  sourceRoot: string,
+): Promise<void> {
+  try {
+    // Resolve the symlink and ensure it cannot escape the source root
+    const resolvedPath = await assertRealPathWithinRoot(
+      sourceRoot,
+      src,
+      "Symlink source",
+    );
+    const stats = await stat(resolvedPath);
+
+    if (stats.isFile()) {
+      // Copy the target file content
+      await copyFile(resolvedPath, dest);
+    }
+    // If symlink points to a directory, we skip it (rare case, could be handled if needed)
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to copy symlink ${src} to ${dest}: ${message}`);
+  }
+}
+
+async function copyFileWithOverwriteOption(
+  src: string,
+  dest: string,
+  overwriteExisting: boolean,
+): Promise<void> {
+  if (!overwriteExisting && (await pathExists(dest))) {
+    return;
+  }
+
+  await copyFile(src, dest);
+}
+
+async function copySymlinkAsFileWithOverwriteOption(
+  src: string,
+  dest: string,
+  sourceRoot: string,
+  overwriteExisting: boolean,
+): Promise<void> {
+  if (!overwriteExisting && (await pathExists(dest))) {
+    return;
+  }
+
+  await copySymlinkAsFile(src, dest, sourceRoot);
+}
+
+/**
+ * Check if a path should be excluded based on exclusion rules.
+ * Uses normalized paths (forward slashes) to ensure consistent matching
+ * on both Windows and Unix systems.
+ */
+export function shouldExclude(
+  relativePath: string,
+  name: string,
+  exclude: string[]
+): boolean {
+  // Check if the name matches any exclusion
+  if (exclude.includes(name)) {
+    return true;
+  }
+
+  // Normalize the relative path for cross-platform comparison
+  // This ensures Windows backslash paths match forward-slash exclusion patterns
+  const normalizedPath = normalizePath(relativePath);
+
+  // Check if the relative path starts with any exclusion
+  for (const ex of exclude) {
+    const normalizedExclusion = normalizePath(ex);
+    if (
+      normalizedPath === normalizedExclusion ||
+      normalizedPath.startsWith(`${normalizedExclusion}/`)
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Recursively copy a directory with exclusions
+ *
+ * @param src Source directory path
+ * @param dest Destination directory path
+ * @param options Copy options including exclusions
+ * @param rootSrc Root source path for calculating relative paths (used internally)
+ * @throws Error if the copy operation fails or path traversal is detected
+ */
+async function copyDirInternal(
+  src: string,
+  dest: string,
+  options: CopyOptions = {},
+  rootSrc?: string,
+  rootDest?: string,
+  overwriteExisting: boolean = true,
+): Promise<void> {
+  try {
+    const { exclude = [], skipOppositeScripts = true } = options;
+    const root = rootSrc ?? src;
+    const destinationRoot = rootDest ?? dest;
+
+    assertPathWithinRoot(root, src, "Source path");
+    assertPathWithinRoot(destinationRoot, dest, "Destination path");
+
+    await assertRealPathWithinRoot(root, src, "Source path");
+
+    // Create destination directory
+    await ensureDir(dest);
+
+    // Read source directory entries
+    const entries = await readdir(src, { withFileTypes: true });
+
+    // Get the opposite script extension for filtering
+    const oppositeExt = getOppositeScriptExtension();
+
+    // Process entries in parallel for better performance
+    const copyPromises: Promise<void>[] = [];
+
+    for (const entry of entries) {
+      const srcPath = join(src, entry.name);
+      const destPath = join(dest, entry.name);
+
+      assertPathWithinRoot(root, srcPath, "Source entry path");
+      assertPathWithinRoot(destinationRoot, destPath, "Destination entry path");
+
+      if (!isPathSafe(src, entry.name) || !isPathSafe(dest, entry.name)) {
+        throw new Error(`Path traversal detected: ${entry.name}`);
+      }
+
+      // Calculate relative path from root using path.relative for cross-platform support
+      const relativePath = relative(root, srcPath);
+
+      if (relativePath.startsWith("..")) {
+        throw new Error(`Path traversal detected: ${srcPath}`);
+      }
+
+      // Check if this path should be excluded
+      if (shouldExclude(relativePath, entry.name, exclude)) {
+        continue;
+      }
+
+      // Skip scripts for the opposite platform
+      if (skipOppositeScripts && extname(entry.name) === oppositeExt) {
+        continue;
+      }
+
+      if (entry.isDirectory()) {
+        // Directories are processed recursively (which will parallelize their contents)
+        copyPromises.push(
+          copyDirInternal(
+            srcPath,
+            destPath,
+            options,
+            root,
+            destinationRoot,
+            overwriteExisting,
+          ),
+        );
+      } else if (entry.isFile()) {
+        copyPromises.push(
+          copyFileWithOverwriteOption(srcPath, destPath, overwriteExisting),
+        );
+      } else if (entry.isSymbolicLink()) {
+        // Dereference symlinks: resolve target and copy as regular file
+        copyPromises.push(
+          copySymlinkAsFileWithOverwriteOption(
+            srcPath,
+            destPath,
+            root,
+            overwriteExisting,
+          ),
+        );
+      }
+      // Skip other special files (block devices, etc.)
+    }
+
+    // Wait for all copy operations to complete
+    await Promise.all(copyPromises);
+  } catch (error) {
+    // Re-throw errors with more context if they don't already have it
+    if (error instanceof Error && error.message.includes("Failed to copy")) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to copy directory ${src} to ${dest}: ${message}`);
+  }
+}
+
+/**
+ * Recursively copy a directory, overwriting existing destination files.
+ */
+export async function copyDir(
+  src: string,
+  dest: string,
+  options: CopyOptions = {},
+  rootSrc?: string,
+  rootDest?: string,
+): Promise<void> {
+  await copyDirInternal(src, dest, options, rootSrc, rootDest, true);
+}
+
+/**
+ * Recursively copy a directory without overwriting existing destination files.
+ */
+export async function copyDirNonDestructive(
+  src: string,
+  dest: string,
+  options: CopyOptions = {},
+  rootSrc?: string,
+  rootDest?: string,
+): Promise<void> {
+  await copyDirInternal(src, dest, options, rootSrc, rootDest, false);
+}
+
+/**
+ * Check if a path exists
+ */
+export async function pathExists(path: string): Promise<boolean> {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if a path is a directory
+ */
+export async function isDirectory(path: string): Promise<boolean> {
+  try {
+    const stats = await stat(path);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if a file is empty or contains only whitespace.
+ * 
+ * A file is considered empty if:
+ * - It does not exist (returns true to allow overwrite)
+ * - It has 0 bytes
+ * - It contains only whitespace characters (for files under 1KB)
+ * 
+ * @param path - The path to the file to check
+ * @returns true if the file is empty or whitespace-only, false otherwise
+ */
+export async function isFileEmpty(path: string): Promise<boolean> {
+  try {
+    const stats = await stat(path);
+    
+    // 0-byte files are empty
+    if (stats.size === 0) {
+      return true;
+    }
+    
+    // For small files (under 1KB), check if content is whitespace-only
+    if (stats.size < 1024) {
+      const content = await readFile(path, "utf-8");
+      return content.trim().length === 0;
+    }
+    
+    // Large files with content are not empty
+    return false;
+  } catch {
+    // If file doesn't exist or can't be read, treat as empty (allow overwrite)
+    return true;
+  }
+}