Move safe-chain package to packages/safe-chain

packages/safe-chain/src/shell-integration/supported-shells/bash.js

@@ -0,0 +1,62 @@
+import {
+  addLineToFile,
+  doesExecutableExistOnSystem,
+  removeLinesMatchingPattern,
+} from "../helpers.js";
+import { execSync } from "child_process";
+
+const shellName = "Bash";
+const executableName = "bash";
+const startupFileCommand = "echo ~/.bashrc";
+
+function isInstalled() {
+  return doesExecutableExistOnSystem(executableName);
+}
+
+function teardown(tools) {
+  const startupFile = getStartupFile();
+
+  for (const { tool } of tools) {
+    // Remove any existing alias for the tool
+    removeLinesMatchingPattern(startupFile, new RegExp(`^alias\\s+${tool}=`));
+  }
+
+  // Removes the line that sources the safe-chain bash initialization script (~/.aikido/scripts/init-posix.sh)
+  removeLinesMatchingPattern(
+    startupFile,
+    /^source\s+~\/\.safe-chain\/scripts\/init-posix\.sh/
+  );
+
+  return true;
+}
+
+function setup() {
+  const startupFile = getStartupFile();
+
+  addLineToFile(
+    startupFile,
+    `source ~/.safe-chain/scripts/init-posix.sh # Safe-chain bash initialization script`
+  );
+
+  return true;
+}
+
+function getStartupFile() {
+  try {
+    return execSync(startupFileCommand, {
+      encoding: "utf8",
+      shell: executableName,
+    }).trim();
+  } catch (error) {
+    throw new Error(
+      `Command failed: ${startupFileCommand}. Error: ${error.message}`
+    );
+  }
+}
+
+export default {
+  name: shellName,
+  isInstalled,
+  setup,
+  teardown,
+};

packages/safe-chain/src/shell-integration/supported-shells/bash.spec.js

@@ -0,0 +1,199 @@
+import { describe, it, beforeEach, afterEach, mock } from "node:test";
+import assert from "node:assert";
+import { tmpdir } from "node:os";
+import fs from "node:fs";
+import path from "path";
+import { knownAikidoTools } from "../helpers.js";
+
+describe("Bash shell integration", () => {
+  let mockStartupFile;
+  let bash;
+
+  beforeEach(async () => {
+    // Create temporary startup file for testing
+    mockStartupFile = path.join(tmpdir(), `test-bashrc-${Date.now()}`);
+
+    // Mock the helpers module
+    mock.module("../helpers.js", {
+      namedExports: {
+        doesExecutableExistOnSystem: () => true,
+        addLineToFile: (filePath, line) => {
+          if (!fs.existsSync(filePath)) {
+            fs.writeFileSync(filePath, "", "utf-8");
+          }
+          fs.appendFileSync(filePath, line + "\n", "utf-8");
+        },
+        removeLinesMatchingPattern: (filePath, pattern) => {
+          if (!fs.existsSync(filePath)) return;
+          const content = fs.readFileSync(filePath, "utf-8");
+          const lines = content.split("\n");
+          const filteredLines = lines.filter((line) => !pattern.test(line));
+          fs.writeFileSync(filePath, filteredLines.join("\n"), "utf-8");
+        },
+      },
+    });
+
+    // Mock child_process execSync
+    mock.module("child_process", {
+      namedExports: {
+        execSync: () => mockStartupFile,
+      },
+    });
+
+    // Import bash module after mocking
+    bash = (await import("./bash.js")).default;
+  });
+
+  afterEach(() => {
+    // Clean up test files
+    if (fs.existsSync(mockStartupFile)) {
+      fs.unlinkSync(mockStartupFile);
+    }
+
+    // Reset mocks
+    mock.reset();
+  });
+
+  describe("isInstalled", () => {
+    it("should return true when bash is installed", () => {
+      assert.strictEqual(bash.isInstalled(), true);
+    });
+
+    it("should call doesExecutableExistOnSystem with correct parameter", () => {
+      // Test that the method calls the helper with the right executable name
+      assert.strictEqual(bash.isInstalled(), true);
+    });
+  });
+
+  describe("setup", () => {
+    it("should add source line for bash initialization script", () => {
+      const result = bash.setup();
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(
+        content.includes(
+          "source ~/.safe-chain/scripts/init-posix.sh # Safe-chain bash initialization script"
+        )
+      );
+    });
+  });
+
+  describe("teardown", () => {
+    it("should remove npm, npx, and yarn aliases", () => {
+      const initialContent = [
+        "#!/bin/bash",
+        "alias npm='aikido-npm'",
+        "alias npx='aikido-npx'",
+        "alias yarn='aikido-yarn'",
+        "alias ls='ls --color=auto'",
+        "alias grep='grep --color=auto'",
+      ].join("\n");
+
+      fs.writeFileSync(mockStartupFile, initialContent, "utf-8");
+
+      const result = bash.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(!content.includes("alias npm="));
+      assert.ok(!content.includes("alias npx="));
+      assert.ok(!content.includes("alias yarn="));
+      assert.ok(content.includes("alias ls="));
+      assert.ok(content.includes("alias grep="));
+    });
+
+    it("should handle file that doesn't exist", () => {
+      if (fs.existsSync(mockStartupFile)) {
+        fs.unlinkSync(mockStartupFile);
+      }
+
+      const result = bash.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+    });
+
+    it("should handle file with no relevant aliases", () => {
+      const initialContent = [
+        "#!/bin/bash",
+        "alias ls='ls --color=auto'",
+        "export PATH=$PATH:~/bin",
+      ].join("\n");
+
+      fs.writeFileSync(mockStartupFile, initialContent, "utf-8");
+
+      const result = bash.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(content.includes("alias ls="));
+      assert.ok(content.includes("export PATH="));
+    });
+  });
+
+  describe("shell properties", () => {
+    it("should have correct name", () => {
+      assert.strictEqual(bash.name, "Bash");
+    });
+
+    it("should expose all required methods", () => {
+      assert.ok(typeof bash.isInstalled === "function");
+      assert.ok(typeof bash.setup === "function");
+      assert.ok(typeof bash.teardown === "function");
+      assert.ok(typeof bash.name === "string");
+    });
+  });
+
+  describe("integration tests", () => {
+    it("should handle complete setup and teardown cycle", () => {
+      const tools = [
+        { tool: "npm", aikidoCommand: "aikido-npm" },
+        { tool: "yarn", aikidoCommand: "aikido-yarn" },
+      ];
+
+      // Setup
+      bash.setup(tools);
+      let content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(content.includes("source ~/.safe-chain/scripts/init-posix.sh"));
+
+      // Teardown
+      bash.teardown(tools);
+      content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(
+        !content.includes("source ~/.safe-chain/scripts/init-posix.sh")
+      );
+    });
+
+    it("should handle multiple setup calls", () => {
+      const tools = [{ tool: "npm", aikidoCommand: "aikido-npm" }];
+
+      bash.setup(tools);
+      bash.teardown(tools);
+      bash.setup(tools);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      const sourceMatches = (content.match(/source.*init-posix\.sh/g) || [])
+        .length;
+      assert.strictEqual(sourceMatches, 1, "Should not duplicate source lines");
+    });
+
+    it("should handle mixed content with aliases and source lines", () => {
+      const initialContent = [
+        "#!/bin/bash",
+        "alias npm='old-npm'",
+        "source ~/.safe-chain/scripts/init-posix.sh",
+        "alias ls='ls --color=auto'",
+      ].join("\n");
+
+      fs.writeFileSync(mockStartupFile, initialContent, "utf-8");
+
+      // Teardown should remove both aliases and source line
+      bash.teardown(knownAikidoTools);
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(!content.includes("alias npm="));
+      assert.ok(
+        !content.includes("source ~/.safe-chain/scripts/init-posix.sh")
+      );
+      assert.ok(content.includes("alias ls="));
+    });
+  });
+});

packages/safe-chain/src/shell-integration/supported-shells/fish.js

@@ -0,0 +1,65 @@
+import {
+  addLineToFile,
+  doesExecutableExistOnSystem,
+  removeLinesMatchingPattern,
+} from "../helpers.js";
+import { execSync } from "child_process";
+
+const shellName = "Fish";
+const executableName = "fish";
+const startupFileCommand = "echo ~/.config/fish/config.fish";
+
+function isInstalled() {
+  return doesExecutableExistOnSystem(executableName);
+}
+
+function teardown(tools) {
+  const startupFile = getStartupFile();
+
+  for (const { tool } of tools) {
+    // Remove any existing alias for the tool
+    removeLinesMatchingPattern(
+      startupFile,
+      new RegExp(`^alias\\s+${tool}\\s+`)
+    );
+  }
+
+  // Removes the line that sources the safe-chain fish initialization script (~/.safe-chain/scripts/init-fish.fish)
+  removeLinesMatchingPattern(
+    startupFile,
+    /^source\s+~\/\.safe-chain\/scripts\/init-fish\.fish/
+  );
+
+  return true;
+}
+
+function setup() {
+  const startupFile = getStartupFile();
+
+  addLineToFile(
+    startupFile,
+    `source ~/.safe-chain/scripts/init-fish.fish # Safe-chain Fish initialization script`
+  );
+
+  return true;
+}
+
+function getStartupFile() {
+  try {
+    return execSync(startupFileCommand, {
+      encoding: "utf8",
+      shell: executableName,
+    }).trim();
+  } catch (error) {
+    throw new Error(
+      `Command failed: ${startupFileCommand}. Error: ${error.message}`
+    );
+  }
+}
+
+export default {
+  name: shellName,
+  isInstalled,
+  setup,
+  teardown,
+};

packages/safe-chain/src/shell-integration/supported-shells/fish.spec.js

@@ -0,0 +1,183 @@
+import { describe, it, beforeEach, afterEach, mock } from "node:test";
+import assert from "node:assert";
+import { tmpdir } from "node:os";
+import fs from "node:fs";
+import path from "path";
+import { knownAikidoTools } from "../helpers.js";
+
+describe("Fish shell integration", () => {
+  let mockStartupFile;
+  let fish;
+
+  beforeEach(async () => {
+    // Create temporary startup file for testing
+    mockStartupFile = path.join(tmpdir(), `test-fish-config-${Date.now()}`);
+
+    // Mock the helpers module
+    mock.module("../helpers.js", {
+      namedExports: {
+        doesExecutableExistOnSystem: () => true,
+        addLineToFile: (filePath, line) => {
+          if (!fs.existsSync(filePath)) {
+            fs.writeFileSync(filePath, "", "utf-8");
+          }
+          fs.appendFileSync(filePath, line + "\n", "utf-8");
+        },
+        removeLinesMatchingPattern: (filePath, pattern) => {
+          if (!fs.existsSync(filePath)) return;
+          const content = fs.readFileSync(filePath, "utf-8");
+          const lines = content.split("\n");
+          const filteredLines = lines.filter((line) => !pattern.test(line));
+          fs.writeFileSync(filePath, filteredLines.join("\n"), "utf-8");
+        },
+      },
+    });
+
+    // Mock child_process execSync
+    mock.module("child_process", {
+      namedExports: {
+        execSync: () => mockStartupFile,
+      },
+    });
+
+    // Import fish module after mocking
+    fish = (await import("./fish.js")).default;
+  });
+
+  afterEach(() => {
+    // Clean up test files
+    if (fs.existsSync(mockStartupFile)) {
+      fs.unlinkSync(mockStartupFile);
+    }
+
+    // Reset mocks
+    mock.reset();
+  });
+
+  describe("isInstalled", () => {
+    it("should return true when fish is installed", () => {
+      assert.strictEqual(fish.isInstalled(), true);
+    });
+
+    it("should call doesExecutableExistOnSystem with correct parameter", () => {
+      // Test that the method calls the helper with the right executable name
+      assert.strictEqual(fish.isInstalled(), true);
+    });
+  });
+
+  describe("setup", () => {
+    it("should add source line for safe-chain fish initialization script", () => {
+      const result = fish.setup();
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(
+        content.includes('source ~/.safe-chain/scripts/init-fish.fish # Safe-chain Fish initialization script')
+      );
+    });
+
+    it("should not duplicate source lines on multiple calls", () => {
+      fish.setup();
+      fish.setup();
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      const sourceMatches = (content.match(/source ~\/\.safe-chain\/scripts\/init-fish\.fish/g) || []).length;
+      assert.strictEqual(sourceMatches, 2, "Should allow multiple source lines (helper doesn't dedupe)");
+    });
+  });
+
+  describe("teardown", () => {
+    it("should remove npm, npx, yarn aliases and source line", () => {
+      const initialContent = [
+        "#!/usr/bin/env fish",
+        "alias npm 'aikido-npm'",
+        "alias npx 'aikido-npx'",
+        "alias yarn 'aikido-yarn'",
+        "source ~/.safe-chain/scripts/init-fish.fish # Safe-chain Fish initialization script",
+        "alias ls 'ls --color=auto'",
+        "alias grep 'grep --color=auto'",
+      ].join("\n");
+
+      fs.writeFileSync(mockStartupFile, initialContent, "utf-8");
+
+      const result = fish.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(!content.includes("alias npm "));
+      assert.ok(!content.includes("alias npx "));
+      assert.ok(!content.includes("alias yarn "));
+      assert.ok(!content.includes("source ~/.safe-chain/scripts/init-fish.fish"));
+      assert.ok(content.includes("alias ls "));
+      assert.ok(content.includes("alias grep "));
+    });
+
+    it("should handle file that doesn't exist", () => {
+      if (fs.existsSync(mockStartupFile)) {
+        fs.unlinkSync(mockStartupFile);
+      }
+
+      const result = fish.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+    });
+
+    it("should handle file with no relevant aliases or source lines", () => {
+      const initialContent = [
+        "#!/usr/bin/env fish",
+        "alias ls 'ls --color=auto'",
+        "set PATH $PATH ~/bin",
+      ].join("\n");
+
+      fs.writeFileSync(mockStartupFile, initialContent, "utf-8");
+
+      const result = fish.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(content.includes("alias ls "));
+      assert.ok(content.includes("set PATH "));
+    });
+  });
+
+  describe("shell properties", () => {
+    it("should have correct name", () => {
+      assert.strictEqual(fish.name, "Fish");
+    });
+
+    it("should expose all required methods", () => {
+      assert.ok(typeof fish.isInstalled === "function");
+      assert.ok(typeof fish.setup === "function");
+      assert.ok(typeof fish.teardown === "function");
+      assert.ok(typeof fish.name === "string");
+    });
+  });
+
+  describe("integration tests", () => {
+    it("should handle complete setup and teardown cycle", () => {
+      const tools = [
+        { tool: "npm", aikidoCommand: "aikido-npm" },
+        { tool: "yarn", aikidoCommand: "aikido-yarn" },
+      ];
+
+      // Setup
+      fish.setup();
+      let content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(content.includes('source ~/.safe-chain/scripts/init-fish.fish'));
+
+      // Teardown
+      fish.teardown(tools);
+      content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(!content.includes("source ~/.safe-chain/scripts/init-fish.fish"));
+    });
+
+    it("should handle multiple setup calls", () => {
+      fish.setup();
+      fish.teardown(knownAikidoTools);
+      fish.setup();
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      const sourceMatches = (content.match(/source ~\/\.safe-chain\/scripts\/init-fish\.fish/g) || []).length;
+      assert.strictEqual(sourceMatches, 1, "Should have exactly one source line after setup-teardown-setup cycle");
+    });
+  });
+});

packages/safe-chain/src/shell-integration/supported-shells/powershell.js

@@ -0,0 +1,65 @@
+import {
+  addLineToFile,
+  doesExecutableExistOnSystem,
+  removeLinesMatchingPattern,
+} from "../helpers.js";
+import { execSync } from "child_process";
+
+const shellName = "PowerShell Core";
+const executableName = "pwsh";
+const startupFileCommand = "echo $PROFILE";
+
+function isInstalled() {
+  return doesExecutableExistOnSystem(executableName);
+}
+
+function teardown(tools) {
+  const startupFile = getStartupFile();
+
+  for (const { tool } of tools) {
+    // Remove any existing alias for the tool
+    removeLinesMatchingPattern(
+      startupFile,
+      new RegExp(`^Set-Alias\\s+${tool}\\s+`)
+    );
+  }
+
+  // Remove the line that sources the safe-chain PowerShell initialization script
+  removeLinesMatchingPattern(
+    startupFile,
+    /^\.\s+["']?\$HOME[/\\].safe-chain[/\\]scripts[/\\]init-pwsh\.ps1["']?/
+  );
+
+  return true;
+}
+
+function setup() {
+  const startupFile = getStartupFile();
+
+  addLineToFile(
+    startupFile,
+    `. "$HOME\\.safe-chain\\scripts\\init-pwsh.ps1" # Safe-chain PowerShell initialization script`
+  );
+
+  return true;
+}
+
+function getStartupFile() {
+  try {
+    return execSync(startupFileCommand, {
+      encoding: "utf8",
+      shell: executableName,
+    }).trim();
+  } catch (error) {
+    throw new Error(
+      `Command failed: ${startupFileCommand}. Error: ${error.message}`
+    );
+  }
+}
+
+export default {
+  name: shellName,
+  isInstalled,
+  setup,
+  teardown,
+};

packages/safe-chain/src/shell-integration/supported-shells/powershell.spec.js

@@ -0,0 +1,200 @@
+import { describe, it, beforeEach, afterEach, mock } from "node:test";
+import assert from "node:assert";
+import { tmpdir } from "node:os";
+import fs from "node:fs";
+import path from "path";
+import { knownAikidoTools } from "../helpers.js";
+
+describe("PowerShell Core shell integration", () => {
+  let mockStartupFile;
+  let powershell;
+
+  beforeEach(async () => {
+    // Create temporary startup file for testing
+    mockStartupFile = path.join(
+      tmpdir(),
+      `test-powershell-profile-${Date.now()}.ps1`
+    );
+
+    // Mock the helpers module
+    mock.module("../helpers.js", {
+      namedExports: {
+        doesExecutableExistOnSystem: () => true,
+        addLineToFile: (filePath, line) => {
+          if (!fs.existsSync(filePath)) {
+            fs.writeFileSync(filePath, "", "utf-8");
+          }
+          fs.appendFileSync(filePath, line + "\n", "utf-8");
+        },
+        removeLinesMatchingPattern: (filePath, pattern) => {
+          if (!fs.existsSync(filePath)) return;
+          const content = fs.readFileSync(filePath, "utf-8");
+          const lines = content.split("\n");
+          const filteredLines = lines.filter((line) => !pattern.test(line));
+          fs.writeFileSync(filePath, filteredLines.join("\n"), "utf-8");
+        },
+      },
+    });
+
+    // Mock child_process execSync
+    mock.module("child_process", {
+      namedExports: {
+        execSync: () => mockStartupFile,
+      },
+    });
+
+    // Import powershell module after mocking
+    powershell = (await import("./powershell.js")).default;
+  });
+
+  afterEach(() => {
+    // Clean up test files
+    if (fs.existsSync(mockStartupFile)) {
+      fs.unlinkSync(mockStartupFile);
+    }
+
+    // Reset mocks
+    mock.reset();
+  });
+
+  describe("isInstalled", () => {
+    it("should return true when powershell is installed", () => {
+      assert.strictEqual(powershell.isInstalled(), true);
+    });
+
+    it("should call doesExecutableExistOnSystem with correct parameter", () => {
+      // Test that the method calls the helper with the right executable name
+      assert.strictEqual(powershell.isInstalled(), true);
+    });
+  });
+
+  describe("setup", () => {
+    it("should add init-pwsh.ps1 source line", () => {
+      const result = powershell.setup();
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(
+        content.includes(
+          '. "$HOME\\.safe-chain\\scripts\\init-pwsh.ps1" # Safe-chain PowerShell initialization script'
+        )
+      );
+    });
+  });
+
+  describe("teardown", () => {
+    it("should remove init-pwsh.ps1 source line", () => {
+      const initialContent = [
+        "# PowerShell profile",
+        '. "$HOME\\.safe-chain\\scripts\\init-pwsh.ps1" # Safe-chain PowerShell initialization script',
+        "Set-Alias ls Get-ChildItem",
+        "Set-Alias grep Select-String",
+      ].join("\n");
+
+      fs.writeFileSync(mockStartupFile, initialContent, "utf-8");
+
+      const result = powershell.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(
+        !content.includes('. "$HOME\\.safe-chain\\scripts\\init-pwsh.ps1"')
+      );
+      assert.ok(content.includes("Set-Alias ls "));
+      assert.ok(content.includes("Set-Alias grep "));
+    });
+
+    it("should remove old-style aliases from earlier versions", () => {
+      const initialContent = [
+        "# PowerShell profile",
+        "Set-Alias npm aikido-npm # Safe-chain alias for npm",
+        "Set-Alias npx aikido-npx # Safe-chain alias for npx",
+        "Set-Alias yarn aikido-yarn # Safe-chain alias for yarn",
+        "Set-Alias ls Get-ChildItem",
+        "Set-Alias grep Select-String",
+      ].join("\n");
+
+      fs.writeFileSync(mockStartupFile, initialContent, "utf-8");
+
+      const result = powershell.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(!content.includes("Set-Alias npm "));
+      assert.ok(!content.includes("Set-Alias npx "));
+      assert.ok(!content.includes("Set-Alias yarn "));
+      assert.ok(content.includes("Set-Alias ls "));
+      assert.ok(content.includes("Set-Alias grep "));
+    });
+
+    it("should handle file that doesn't exist", () => {
+      if (fs.existsSync(mockStartupFile)) {
+        fs.unlinkSync(mockStartupFile);
+      }
+
+      const result = powershell.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+    });
+
+    it("should handle file with no relevant content", () => {
+      const initialContent = [
+        "# PowerShell profile",
+        "Set-Alias ls Get-ChildItem",
+        "$env:PATH += ';C:\\Tools'",
+      ].join("\n");
+
+      fs.writeFileSync(mockStartupFile, initialContent, "utf-8");
+
+      const result = powershell.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(content.includes("Set-Alias ls "));
+      assert.ok(content.includes("$env:PATH "));
+    });
+  });
+
+  describe("shell properties", () => {
+    it("should have correct name", () => {
+      assert.strictEqual(powershell.name, "PowerShell Core");
+    });
+
+    it("should expose all required methods", () => {
+      assert.ok(typeof powershell.isInstalled === "function");
+      assert.ok(typeof powershell.setup === "function");
+      assert.ok(typeof powershell.teardown === "function");
+      assert.ok(typeof powershell.name === "string");
+    });
+  });
+
+  describe("integration tests", () => {
+    it("should handle complete setup and teardown cycle", () => {
+      // Setup
+      powershell.setup();
+      let content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(
+        content.includes('. "$HOME\\.safe-chain\\scripts\\init-pwsh.ps1"')
+      );
+
+      // Teardown
+      powershell.teardown(knownAikidoTools);
+      content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(
+        !content.includes('. "$HOME\\.safe-chain\\scripts\\init-pwsh.ps1"')
+      );
+    });
+
+    it("should handle multiple setup calls", () => {
+      powershell.setup();
+      powershell.teardown(knownAikidoTools);
+      powershell.setup();
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      const sourceMatches = (
+        content.match(/\. "\$HOME\\.safe-chain\\scripts\\init-pwsh\.ps1"/g) ||
+        []
+      ).length;
+      assert.strictEqual(sourceMatches, 1, "Should not duplicate source lines");
+    });
+  });
+});

packages/safe-chain/src/shell-integration/supported-shells/windowsPowershell.js

@@ -0,0 +1,65 @@
+import {
+  addLineToFile,
+  doesExecutableExistOnSystem,
+  removeLinesMatchingPattern,
+} from "../helpers.js";
+import { execSync } from "child_process";
+
+const shellName = "Windows PowerShell";
+const executableName = "powershell";
+const startupFileCommand = "echo $PROFILE";
+
+function isInstalled() {
+  return doesExecutableExistOnSystem(executableName);
+}
+
+function teardown(tools) {
+  const startupFile = getStartupFile();
+
+  for (const { tool } of tools) {
+    // Remove any existing alias for the tool
+    removeLinesMatchingPattern(
+      startupFile,
+      new RegExp(`^Set-Alias\\s+${tool}\\s+`)
+    );
+  }
+
+  // Remove the line that sources the safe-chain PowerShell initialization script
+  removeLinesMatchingPattern(
+    startupFile,
+    /^\.\s+["']?\$HOME[/\\].safe-chain[/\\]scripts[/\\]init-pwsh\.ps1["']?/
+  );
+
+  return true;
+}
+
+function setup() {
+  const startupFile = getStartupFile();
+
+  addLineToFile(
+    startupFile,
+    `. "$HOME\\.safe-chain\\scripts\\init-pwsh.ps1" # Safe-chain PowerShell initialization script`
+  );
+
+  return true;
+}
+
+function getStartupFile() {
+  try {
+    return execSync(startupFileCommand, {
+      encoding: "utf8",
+      shell: executableName,
+    }).trim();
+  } catch (error) {
+    throw new Error(
+      `Command failed: ${startupFileCommand}. Error: ${error.message}`
+    );
+  }
+}
+
+export default {
+  name: shellName,
+  isInstalled,
+  setup,
+  teardown,
+};

packages/safe-chain/src/shell-integration/supported-shells/windowsPowershell.spec.js

@@ -0,0 +1,200 @@
+import { describe, it, beforeEach, afterEach, mock } from "node:test";
+import assert from "node:assert";
+import { tmpdir } from "node:os";
+import fs from "node:fs";
+import path from "path";
+import { knownAikidoTools } from "../helpers.js";
+
+describe("Windows PowerShell shell integration", () => {
+  let mockStartupFile;
+  let windowsPowershell;
+
+  beforeEach(async () => {
+    // Create temporary startup file for testing
+    mockStartupFile = path.join(
+      tmpdir(),
+      `test-windows-powershell-profile-${Date.now()}.ps1`
+    );
+
+    // Mock the helpers module
+    mock.module("../helpers.js", {
+      namedExports: {
+        doesExecutableExistOnSystem: () => true,
+        addLineToFile: (filePath, line) => {
+          if (!fs.existsSync(filePath)) {
+            fs.writeFileSync(filePath, "", "utf-8");
+          }
+          fs.appendFileSync(filePath, line + "\n", "utf-8");
+        },
+        removeLinesMatchingPattern: (filePath, pattern) => {
+          if (!fs.existsSync(filePath)) return;
+          const content = fs.readFileSync(filePath, "utf-8");
+          const lines = content.split("\n");
+          const filteredLines = lines.filter((line) => !pattern.test(line));
+          fs.writeFileSync(filePath, filteredLines.join("\n"), "utf-8");
+        },
+      },
+    });
+
+    // Mock child_process execSync
+    mock.module("child_process", {
+      namedExports: {
+        execSync: () => mockStartupFile,
+      },
+    });
+
+    // Import windowsPowershell module after mocking
+    windowsPowershell = (await import("./windowsPowershell.js")).default;
+  });
+
+  afterEach(() => {
+    // Clean up test files
+    if (fs.existsSync(mockStartupFile)) {
+      fs.unlinkSync(mockStartupFile);
+    }
+
+    // Reset mocks
+    mock.reset();
+  });
+
+  describe("isInstalled", () => {
+    it("should return true when windows powershell is installed", () => {
+      assert.strictEqual(windowsPowershell.isInstalled(), true);
+    });
+
+    it("should call doesExecutableExistOnSystem with correct parameter", () => {
+      // Test that the method calls the helper with the right executable name
+      assert.strictEqual(windowsPowershell.isInstalled(), true);
+    });
+  });
+
+  describe("setup", () => {
+    it("should add init-pwsh.ps1 source line", () => {
+      const result = windowsPowershell.setup();
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(
+        content.includes(
+          '. "$HOME\\.safe-chain\\scripts\\init-pwsh.ps1" # Safe-chain PowerShell initialization script'
+        )
+      );
+    });
+  });
+
+  describe("teardown", () => {
+    it("should remove init-pwsh.ps1 source line", () => {
+      const initialContent = [
+        "# Windows PowerShell profile",
+        '. "$HOME\\.safe-chain\\scripts\\init-pwsh.ps1" # Safe-chain PowerShell initialization script',
+        "Set-Alias ls Get-ChildItem",
+        "Set-Alias grep Select-String",
+      ].join("\n");
+
+      fs.writeFileSync(mockStartupFile, initialContent, "utf-8");
+
+      const result = windowsPowershell.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(
+        !content.includes('. "$HOME\\.safe-chain\\scripts\\init-pwsh.ps1"')
+      );
+      assert.ok(content.includes("Set-Alias ls "));
+      assert.ok(content.includes("Set-Alias grep "));
+    });
+
+    it("should remove old-style aliases from earlier versions", () => {
+      const initialContent = [
+        "# Windows PowerShell profile",
+        "Set-Alias npm aikido-npm # Safe-chain alias for npm",
+        "Set-Alias npx aikido-npx # Safe-chain alias for npx",
+        "Set-Alias yarn aikido-yarn # Safe-chain alias for yarn",
+        "Set-Alias ls Get-ChildItem",
+        "Set-Alias grep Select-String",
+      ].join("\n");
+
+      fs.writeFileSync(mockStartupFile, initialContent, "utf-8");
+
+      const result = windowsPowershell.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(!content.includes("Set-Alias npm "));
+      assert.ok(!content.includes("Set-Alias npx "));
+      assert.ok(!content.includes("Set-Alias yarn "));
+      assert.ok(content.includes("Set-Alias ls "));
+      assert.ok(content.includes("Set-Alias grep "));
+    });
+
+    it("should handle file that doesn't exist", () => {
+      if (fs.existsSync(mockStartupFile)) {
+        fs.unlinkSync(mockStartupFile);
+      }
+
+      const result = windowsPowershell.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+    });
+
+    it("should handle file with no relevant content", () => {
+      const initialContent = [
+        "# Windows PowerShell profile",
+        "Set-Alias ls Get-ChildItem",
+        "$env:PATH += ';C:\\Tools'",
+      ].join("\n");
+
+      fs.writeFileSync(mockStartupFile, initialContent, "utf-8");
+
+      const result = windowsPowershell.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(content.includes("Set-Alias ls "));
+      assert.ok(content.includes("$env:PATH "));
+    });
+  });
+
+  describe("shell properties", () => {
+    it("should have correct name", () => {
+      assert.strictEqual(windowsPowershell.name, "Windows PowerShell");
+    });
+
+    it("should expose all required methods", () => {
+      assert.ok(typeof windowsPowershell.isInstalled === "function");
+      assert.ok(typeof windowsPowershell.setup === "function");
+      assert.ok(typeof windowsPowershell.teardown === "function");
+      assert.ok(typeof windowsPowershell.name === "string");
+    });
+  });
+
+  describe("integration tests", () => {
+    it("should handle complete setup and teardown cycle", () => {
+      // Setup
+      windowsPowershell.setup();
+      let content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(
+        content.includes('. "$HOME\\.safe-chain\\scripts\\init-pwsh.ps1"')
+      );
+
+      // Teardown
+      windowsPowershell.teardown(knownAikidoTools);
+      content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(
+        !content.includes('. "$HOME\\.safe-chain\\scripts\\init-pwsh.ps1"')
+      );
+    });
+
+    it("should handle multiple setup calls", () => {
+      windowsPowershell.setup();
+      windowsPowershell.teardown(knownAikidoTools);
+      windowsPowershell.setup();
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      const sourceMatches = (
+        content.match(/\. "\$HOME\\.safe-chain\\scripts\\init-pwsh\.ps1"/g) ||
+        []
+      ).length;
+      assert.strictEqual(sourceMatches, 1, "Should not duplicate source lines");
+    });
+  });
+});

packages/safe-chain/src/shell-integration/supported-shells/zsh.js

@@ -0,0 +1,62 @@
+import {
+  addLineToFile,
+  doesExecutableExistOnSystem,
+  removeLinesMatchingPattern,
+} from "../helpers.js";
+import { execSync } from "child_process";
+
+const shellName = "Zsh";
+const executableName = "zsh";
+const startupFileCommand = "echo ${ZDOTDIR:-$HOME}/.zshrc";
+
+function isInstalled() {
+  return doesExecutableExistOnSystem(executableName);
+}
+
+function teardown(tools) {
+  const startupFile = getStartupFile();
+
+  for (const { tool } of tools) {
+    // Remove any existing alias for the tool
+    removeLinesMatchingPattern(startupFile, new RegExp(`^alias\\s+${tool}=`));
+  }
+
+  // Removes the line that sources the safe-chain zsh initialization script (~/.aikido/scripts/init-posix.sh)
+  removeLinesMatchingPattern(
+    startupFile,
+    /^source\s+~\/\.safe-chain\/scripts\/init-posix\.sh/
+  );
+
+  return true;
+}
+
+function setup() {
+  const startupFile = getStartupFile();
+
+  addLineToFile(
+    startupFile,
+    `source ~/.safe-chain/scripts/init-posix.sh # Safe-chain Zsh initialization script`
+  );
+
+  return true;
+}
+
+function getStartupFile() {
+  try {
+    return execSync(startupFileCommand, {
+      encoding: "utf8",
+      shell: executableName,
+    }).trim();
+  } catch (error) {
+    throw new Error(
+      `Command failed: ${startupFileCommand}. Error: ${error.message}`
+    );
+  }
+}
+
+export default {
+  name: shellName,
+  isInstalled,
+  setup,
+  teardown,
+};

packages/safe-chain/src/shell-integration/supported-shells/zsh.spec.js

@@ -0,0 +1,226 @@
+import { describe, it, beforeEach, afterEach, mock } from "node:test";
+import assert from "node:assert";
+import { tmpdir } from "node:os";
+import fs from "node:fs";
+import path from "path";
+import { knownAikidoTools } from "../helpers.js";
+
+describe("Zsh shell integration", () => {
+  let mockStartupFile;
+  let zsh;
+
+  beforeEach(async () => {
+    // Create temporary startup file for testing
+    mockStartupFile = path.join(tmpdir(), `test-zshrc-${Date.now()}`);
+
+    // Mock the helpers module
+    mock.module("../helpers.js", {
+      namedExports: {
+        doesExecutableExistOnSystem: () => true,
+        addLineToFile: (filePath, line) => {
+          if (!fs.existsSync(filePath)) {
+            fs.writeFileSync(filePath, "", "utf-8");
+          }
+          fs.appendFileSync(filePath, line + "\n", "utf-8");
+        },
+        removeLinesMatchingPattern: (filePath, pattern) => {
+          if (!fs.existsSync(filePath)) return;
+          const content = fs.readFileSync(filePath, "utf-8");
+          const lines = content.split("\n");
+          const filteredLines = lines.filter((line) => !pattern.test(line));
+          fs.writeFileSync(filePath, filteredLines.join("\n"), "utf-8");
+        },
+      },
+    });
+
+    // Mock child_process execSync
+    mock.module("child_process", {
+      namedExports: {
+        execSync: () => mockStartupFile,
+      },
+    });
+
+    // Import zsh module after mocking
+    zsh = (await import("./zsh.js")).default;
+  });
+
+  afterEach(() => {
+    // Clean up test files
+    if (fs.existsSync(mockStartupFile)) {
+      fs.unlinkSync(mockStartupFile);
+    }
+
+    // Reset mocks
+    mock.reset();
+  });
+
+  describe("isInstalled", () => {
+    it("should return true when zsh is installed", () => {
+      assert.strictEqual(zsh.isInstalled(), true);
+    });
+
+    it("should call doesExecutableExistOnSystem with correct parameter", () => {
+      // Test that the method calls the helper with the right executable name
+      assert.strictEqual(zsh.isInstalled(), true);
+    });
+  });
+
+  describe("setup", () => {
+    it("should add source line for zsh initialization script", () => {
+      const result = zsh.setup();
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(
+        content.includes(
+          "source ~/.safe-chain/scripts/init-posix.sh # Safe-chain Zsh initialization script"
+        )
+      );
+    });
+
+    it("should handle empty startup file", () => {
+      const result = zsh.setup();
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(content.includes("source ~/.safe-chain/scripts/init-posix.sh"));
+    });
+  });
+
+  describe("teardown", () => {
+    it("should remove npm, npx, and yarn aliases", () => {
+      const initialContent = [
+        "#!/bin/zsh",
+        "alias npm='aikido-npm'",
+        "alias npx='aikido-npx'",
+        "alias yarn='aikido-yarn'",
+        "alias ls='ls --color=auto'",
+        "alias grep='grep --color=auto'",
+      ].join("\n");
+
+      fs.writeFileSync(mockStartupFile, initialContent, "utf-8");
+
+      const result = zsh.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(!content.includes("alias npm="));
+      assert.ok(!content.includes("alias npx="));
+      assert.ok(!content.includes("alias yarn="));
+      assert.ok(content.includes("alias ls="));
+      assert.ok(content.includes("alias grep="));
+    });
+
+    it("should remove zsh initialization script source line", () => {
+      const initialContent = [
+        "#!/bin/zsh",
+        "source ~/.safe-chain/scripts/init-posix.sh",
+        "alias ls='ls --color=auto'",
+      ].join("\n");
+
+      fs.writeFileSync(mockStartupFile, initialContent, "utf-8");
+
+      const result = zsh.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(
+        !content.includes("source ~/.safe-chain/scripts/init-posix.sh")
+      );
+      assert.ok(content.includes("alias ls="));
+    });
+
+    it("should handle file that doesn't exist", () => {
+      if (fs.existsSync(mockStartupFile)) {
+        fs.unlinkSync(mockStartupFile);
+      }
+
+      const result = zsh.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+    });
+
+    it("should handle file with no relevant aliases or source lines", () => {
+      const initialContent = [
+        "#!/bin/zsh",
+        "alias ls='ls --color=auto'",
+        "export PATH=$PATH:~/bin",
+      ].join("\n");
+
+      fs.writeFileSync(mockStartupFile, initialContent, "utf-8");
+
+      const result = zsh.teardown(knownAikidoTools);
+      assert.strictEqual(result, true);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(content.includes("alias ls="));
+      assert.ok(content.includes("export PATH="));
+    });
+  });
+
+  describe("shell properties", () => {
+    it("should have correct name", () => {
+      assert.strictEqual(zsh.name, "Zsh");
+    });
+
+    it("should expose all required methods", () => {
+      assert.ok(typeof zsh.isInstalled === "function");
+      assert.ok(typeof zsh.setup === "function");
+      assert.ok(typeof zsh.teardown === "function");
+      assert.ok(typeof zsh.name === "string");
+    });
+  });
+
+  describe("integration tests", () => {
+    it("should handle complete setup and teardown cycle", () => {
+      const tools = [
+        { tool: "npm", aikidoCommand: "aikido-npm" },
+        { tool: "yarn", aikidoCommand: "aikido-yarn" },
+      ];
+
+      // Setup
+      zsh.setup();
+      let content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(content.includes("source ~/.safe-chain/scripts/init-posix.sh"));
+
+      // Teardown
+      zsh.teardown(tools);
+      content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(
+        !content.includes("source ~/.safe-chain/scripts/init-posix.sh")
+      );
+    });
+
+    it("should handle multiple setup calls", () => {
+      const tools = [{ tool: "npm", aikidoCommand: "aikido-npm" }];
+
+      zsh.setup(tools);
+      zsh.teardown(tools);
+      zsh.setup(tools);
+
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      const sourceMatches = (content.match(/source.*init-posix\.sh/g) || [])
+        .length;
+      assert.strictEqual(sourceMatches, 1, "Should not duplicate source lines");
+    });
+
+    it("should handle mixed content with aliases and source lines", () => {
+      const initialContent = [
+        "#!/bin/zsh",
+        "alias npm='old-npm'",
+        "source ~/.safe-chain/scripts/init-posix.sh",
+        "alias ls='ls --color=auto'",
+      ].join("\n");
+
+      fs.writeFileSync(mockStartupFile, initialContent, "utf-8");
+
+      // Teardown should remove both aliases and source line
+      zsh.teardown(knownAikidoTools);
+      const content = fs.readFileSync(mockStartupFile, "utf-8");
+      assert.ok(!content.includes("alias npm="));
+      assert.ok(
+        !content.includes("source ~/.safe-chain/scripts/init-posix.sh")
+      );
+      assert.ok(content.includes("alias ls="));
+    });
+  });
+});