@bastani/atomic 0.5.0-1

package/src/commands/cli/update.ts

@@ -0,0 +1,46 @@
+/**
+ * Update command — upgrades atomic to the latest version via bun and
+ * reinstalls global skills.
+ *
+ * Usage:
+ *   atomic update
+ */
+
+import { COLORS } from "@/theme/colors.ts";
+import { VERSION } from "@/version.ts";
+import { installGlobalSkills } from "@/services/system/skills.ts";
+
+export async function updateCommand(): Promise<number> {
+  const bunPath = Bun.which("bun");
+  if (!bunPath) {
+    console.error(`${COLORS.red}Error: bun is not installed.${COLORS.reset}`);
+    console.error("Install bun: https://bun.sh");
+    return 1;
+  }
+
+  console.log(`Current version: ${VERSION}`);
+  console.log("Updating atomic...\n");
+
+  // Upgrade the package
+  const proc = Bun.spawn([bunPath, "add", "-g", "atomic@latest"], {
+    stdio: ["ignore", "inherit", "inherit"],
+  });
+  const exitCode = await proc.exited;
+
+  if (exitCode !== 0) {
+    console.error(`\n${COLORS.red}Failed to update atomic (exit ${exitCode}).${COLORS.reset}`);
+    return 1;
+  }
+
+  // Reinstall global skills
+  console.log("\nUpdating skills...");
+  try {
+    await installGlobalSkills();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`\n${COLORS.yellow}Warning: failed to install skills: ${message}${COLORS.reset}`);
+  }
+
+  console.log(`\n${COLORS.green}Update complete.${COLORS.reset}`);
+  return 0;
+}

package/src/commands/cli/workflow.ts

@@ -0,0 +1,164 @@
+/**
+ * Workflow CLI command
+ *
+ * Usage:
+ *   atomic workflow -n <name> -a <agent> <prompt>
+ *   atomic workflow --list
+ */
+
+import { AGENT_CONFIG, type AgentKey } from "@/services/config/index.ts";
+import { COLORS } from "@/theme/colors.ts";
+import { isCommandInstalled } from "@/services/system/detect.ts";
+import { ensureTmuxInstalled, ensureBunInstalled } from "../../lib/spawn.ts";
+import {
+  isTmuxInstalled,
+  discoverWorkflows,
+  findWorkflow,
+  executeWorkflow,
+  WorkflowLoader,
+  resetMuxBinaryCache,
+} from "@/sdk/workflows.ts";
+import type { AgentType } from "@/sdk/workflows.ts";
+
+export async function workflowCommand(options: {
+  name?: string;
+  agent?: string;
+  prompt?: string;
+  list?: boolean;
+}): Promise<number> {
+  // List mode
+  if (options.list) {
+    const workflows = await discoverWorkflows(undefined, options.agent as AgentType | undefined);
+
+    if (workflows.length === 0) {
+      console.log("No workflows found.");
+      console.log("Create a workflow in .atomic/workflows/<name>/<agent>/index.ts");
+      return 0;
+    }
+
+    console.log("Available workflows:\n");
+    for (const wf of workflows) {
+      const badge = wf.source === "local" ? "(local)" : "(global)";
+      console.log(`  ${wf.agent}/${wf.name} ${COLORS.dim}${badge}${COLORS.reset}`);
+      console.log(`    ${COLORS.dim}${wf.path}${COLORS.reset}`);
+    }
+    return 0;
+  }
+
+  // Run mode — validate inputs
+  if (!options.name) {
+    console.error(`${COLORS.red}Error: Missing workflow name. Use -n <name>.${COLORS.reset}`);
+    return 1;
+  }
+
+  if (!options.agent) {
+    console.error(`${COLORS.red}Error: Missing agent. Use -a <agent>.${COLORS.reset}`);
+    return 1;
+  }
+
+  const validAgents = Object.keys(AGENT_CONFIG);
+  if (!validAgents.includes(options.agent)) {
+    console.error(`${COLORS.red}Error: Unknown agent '${options.agent}'.${COLORS.reset}`);
+    console.error(`Valid agents: ${validAgents.join(", ")}`);
+    return 1;
+  }
+
+  const agent = options.agent as AgentKey;
+
+  // Check agent CLI is installed
+  if (!isCommandInstalled(AGENT_CONFIG[agent].cmd)) {
+    console.error(`${COLORS.red}Error: '${AGENT_CONFIG[agent].cmd}' is not installed.${COLORS.reset}`);
+    console.error(`Install it from: ${AGENT_CONFIG[agent].install_url}`);
+    return 1;
+  }
+
+  // Ensure tmux/psmux is installed
+  if (!isTmuxInstalled()) {
+    console.log("Terminal multiplexer not found. Installing...");
+    try {
+      await ensureTmuxInstalled();
+      resetMuxBinaryCache();
+    } catch {
+      // Installation attempt failed — fall through to check below
+    }
+    if (!isTmuxInstalled()) {
+      const isWin = process.platform === "win32";
+      console.error(`${COLORS.red}Error: ${isWin ? "psmux" : "tmux"} is not installed.${COLORS.reset}`);
+      console.error(
+        isWin
+          ? "Install psmux: https://github.com/psmux/psmux#installation"
+          : "Install tmux: https://github.com/tmux/tmux/wiki/Installing",
+      );
+      return 1;
+    }
+  }
+
+  // Ensure bun is installed (required for workflow execution)
+  if (!Bun.which("bun")) {
+    console.log("Bun runtime not found. Installing...");
+    try {
+      await ensureBunInstalled();
+    } catch {
+      // Installation attempt failed — fall through to check below
+    }
+    if (!Bun.which("bun")) {
+      console.error(`${COLORS.red}Error: bun is not installed.${COLORS.reset}`);
+      console.error("Install bun: https://bun.sh");
+      return 1;
+    }
+  }
+
+  // Find the workflow
+  const discovered = await findWorkflow(options.name, agent);
+
+  if (!discovered) {
+    console.error(`${COLORS.red}Error: Workflow '${options.name}' not found for agent '${agent}'.${COLORS.reset}`);
+    console.error(`\nExpected location:`);
+    console.error(`  .atomic/workflows/${options.name}/${agent}/index.ts  ${COLORS.dim}(local)${COLORS.reset}`);
+    console.error(`  ~/.atomic/workflows/${options.name}/${agent}/index.ts ${COLORS.dim}(global)${COLORS.reset}`);
+
+    const available = await discoverWorkflows(undefined, agent);
+    if (available.length > 0) {
+      console.error(`\nAvailable ${agent} workflows:`);
+      for (const wf of available) {
+        console.error(`  ${COLORS.dim}•${COLORS.reset} ${wf.name} ${COLORS.dim}(${wf.source})${COLORS.reset}`);
+      }
+    }
+
+    return 1;
+  }
+
+  // Load workflow through the pipeline: resolve → validate → load.
+  // The loader registers a Bun resolver plugin that maps `atomic/*` and
+  // atomic's installed deps onto the running CLI's own module graph, so
+  // workflow files don't need their own `package.json` / `node_modules`.
+  const result = await WorkflowLoader.loadWorkflow(discovered, {
+    warn(warnings) {
+      for (const w of warnings) {
+        console.warn(`⚠ [${w.rule}] ${w.message}`);
+      }
+    },
+    error(stage, _error, message) {
+      console.error(`${COLORS.red}Error (${stage}): ${message}${COLORS.reset}`);
+    },
+  });
+
+  if (!result.ok) {
+    return 1;
+  }
+
+  // Execute
+  try {
+    await executeWorkflow({
+      definition: result.value.definition,
+      agent,
+      prompt: options.prompt ?? "",
+      workflowFile: discovered.path,
+    });
+    return 0;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`${COLORS.red}Workflow failed: ${message}${COLORS.reset}`);
+    return 1;
+  }
+}

package/src/lib/merge.ts

@@ -0,0 +1,65 @@
+/**
+ * Utilities for merging JSON configuration files
+ */
+
+import { readFile, writeFile } from "fs/promises";
+import { resolve } from "path";
+
+interface McpConfig {
+  mcpServers?: Record<string, unknown>;
+  servers?: Record<string, unknown>;
+  lspServers?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+function mergeNamedObjectMap(
+  destination: Record<string, unknown> | undefined,
+  source: Record<string, unknown> | undefined,
+): Record<string, unknown> | undefined {
+  if (!destination && !source) {
+    return undefined;
+  }
+
+  return {
+    ...destination,
+    ...source,
+  };
+}
+
+/**
+ * Merge source JSON file into destination JSON file
+ * - Preserves all existing keys in destination
+ * - Adds/updates keys from source
+ * - For MCP server maps: preserves user's servers, adds/updates CLI-managed servers
+ *
+ * @param srcPath Path to source JSON file
+ * @param destPath Path to destination JSON file (will be modified in place)
+ */
+export async function mergeJsonFile(
+  srcPath: string,
+  destPath: string
+): Promise<void> {
+  if (resolve(srcPath) === resolve(destPath)) {
+    return;
+  }
+
+  const [srcContent, destContent] = await Promise.all([
+    readFile(srcPath, "utf-8"),
+    readFile(destPath, "utf-8"),
+  ]);
+
+  const srcConfig: McpConfig = JSON.parse(srcContent);
+  const destConfig: McpConfig = JSON.parse(destContent);
+
+  // Merge top-level config - preserve destination's other keys
+  const mergedConfig: McpConfig = {
+    ...destConfig,
+    ...srcConfig,
+  };
+
+  mergedConfig.mcpServers = mergeNamedObjectMap(destConfig.mcpServers, srcConfig.mcpServers);
+  mergedConfig.servers = mergeNamedObjectMap(destConfig.servers, srcConfig.servers);
+  mergedConfig.lspServers = mergeNamedObjectMap(destConfig.lspServers, srcConfig.lspServers);
+
+  await writeFile(destPath, JSON.stringify(mergedConfig, null, 2) + "\n");
+}

package/src/lib/path-root-guard.ts

@@ -0,0 +1,38 @@
+import { realpath } from "fs/promises";
+import { isAbsolute, relative, resolve } from "path";
+
+function isSubPath(rootPath: string, targetPath: string): boolean {
+  const rel = relative(rootPath, targetPath);
+  return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+
+export function isPathWithinRoot(rootPath: string, candidatePath: string): boolean {
+  return isSubPath(resolve(rootPath), resolve(candidatePath));
+}
+
+export function assertPathWithinRoot(
+  rootPath: string,
+  candidatePath: string,
+  label: string,
+): void {
+  if (!isPathWithinRoot(rootPath, candidatePath)) {
+    throw new Error(`${label} escapes allowed root: ${candidatePath}`);
+  }
+}
+
+export async function assertRealPathWithinRoot(
+  rootPath: string,
+  candidatePath: string,
+  label: string,
+): Promise<string> {
+  const [resolvedRootPath, resolvedCandidatePath] = await Promise.all([
+    realpath(rootPath),
+    realpath(candidatePath),
+  ]);
+
+  if (!isSubPath(resolvedRootPath, resolvedCandidatePath)) {
+    throw new Error(`${label} resolves outside allowed root: ${candidatePath}`);
+  }
+
+  return resolvedCandidatePath;
+}