@happier-dev/stack 0.1.0-preview.5.1

package/scripts/worktrees_archive_cmd.integration.test.mjs

@@ -0,0 +1,228 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const scriptsDir = dirname(fileURLToPath(import.meta.url));
+const rootDir = dirname(scriptsDir);
+
+function runCmd(cmd, args, { cwd, env }) {
+  return new Promise((resolve, reject) => {
+    const cleanEnv = {};
+    for (const [k, v] of Object.entries(env ?? {})) {
+      if (v == null) continue;
+      cleanEnv[k] = String(v);
+    }
+    const proc = spawn(cmd, args, { cwd, env: cleanEnv, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (d) => (stdout += String(d)));
+    proc.stderr.on('data', (d) => (stderr += String(d)));
+    proc.on('error', reject);
+    proc.on('close', (code, signal) => {
+      if (code != null) {
+        resolve({ code, stdout, stderr });
+        return;
+      }
+      const signalText = signal ? ` (signal: ${signal})` : '';
+      resolve({ code: 1, stdout, stderr: `${stderr}Process exited without code${signalText}\n` });
+    });
+  });
+}
+
+function runNode(args, { cwd, env }) {
+  return runCmd(process.execPath, args, { cwd, env });
+}
+
+async function runOk(cmd, args, { cwd, env }) {
+  const res = await runCmd(cmd, args, { cwd, env });
+  assert.equal(res.code, 0, `expected exit 0 for ${cmd} ${args.join(' ')}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  return res;
+}
+
+function createBaseEnv({ homeDir, storageDir, workspaceDir }) {
+  return {
+    ...Object.fromEntries(Object.entries(process.env).filter(([k]) => !k.startsWith('HAPPIER_STACK_'))),
+    GIT_TERMINAL_PROMPT: '0',
+    HAPPIER_STACK_HOME_DIR: homeDir,
+    HAPPIER_STACK_STORAGE_DIR: storageDir,
+    HAPPIER_STACK_WORKSPACE_DIR: workspaceDir,
+  };
+}
+
+async function initMainRepo({ repoDir, baseEnv }) {
+  await mkdir(repoDir, { recursive: true });
+  await runOk('git', ['init', '-b', 'main'], { cwd: repoDir, env: baseEnv });
+  await runOk('git', ['config', 'user.name', 'Test'], { cwd: repoDir, env: baseEnv });
+  await runOk('git', ['config', 'user.email', 'test@example.com'], { cwd: repoDir, env: baseEnv });
+  await writeFile(join(repoDir, 'README.md'), 'hello\n', 'utf-8');
+  await runOk('git', ['add', 'README.md'], { cwd: repoDir, env: baseEnv });
+  await runOk('git', ['commit', '-m', 'init'], { cwd: repoDir, env: baseEnv });
+}
+
+async function addWorktree({ repoDir, worktreeDir, branch, baseEnv }) {
+  await mkdir(dirname(worktreeDir), { recursive: true });
+  await runOk('git', ['worktree', 'add', '-b', branch, worktreeDir, 'main'], { cwd: repoDir, env: baseEnv });
+}
+
+async function createArchiveFixture(t, prefix) {
+  const tmp = await mkdtemp(join(tmpdir(), prefix));
+  t.after(async () => {
+    await rm(tmp, { recursive: true, force: true });
+  });
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const workspaceDir = join(tmp, 'workspace');
+  const baseEnv = createBaseEnv({ homeDir, storageDir, workspaceDir });
+  const repoDir = join(workspaceDir, 'main');
+
+  await initMainRepo({ repoDir, baseEnv });
+
+  return {
+    baseEnv,
+    homeDir,
+    repoDir,
+    storageDir,
+    tmp,
+    workspaceDir,
+  };
+}
+
+test('hstack wt archive detaches and moves a git worktree (preserving uncommitted changes)', async (t) => {
+  const { baseEnv, repoDir, workspaceDir } = await createArchiveFixture(t, 'happy-stacks-wt-archive-');
+
+  const worktreeDir = join(workspaceDir, 'pr', 'test-archive');
+  await addWorktree({ repoDir, worktreeDir, branch: 'pr/test-archive', baseEnv });
+
+  await writeFile(join(worktreeDir, 'staged.txt'), 'staged\n', 'utf-8');
+  await runOk('git', ['add', 'staged.txt'], { cwd: worktreeDir, env: baseEnv });
+  await writeFile(join(worktreeDir, 'untracked.txt'), 'untracked\n', 'utf-8');
+  await writeFile(join(worktreeDir, 'README.md'), 'hello\nchanged\n', 'utf-8');
+
+  const beforeStatus = await runOk('git', ['status', '--porcelain'], { cwd: worktreeDir, env: baseEnv });
+  assert.ok(beforeStatus.stdout.includes('A  staged.txt'), `expected staged file in status\n${beforeStatus.stdout}`);
+  assert.ok(beforeStatus.stdout.includes(' M README.md'), `expected modified file in status\n${beforeStatus.stdout}`);
+  assert.ok(beforeStatus.stdout.includes('?? untracked.txt'), `expected untracked file in status\n${beforeStatus.stdout}`);
+
+  const date = '2000-01-02';
+  // Simulate a minimal PATH environment like launchd/SwiftBar shells.
+  const nodeEnv = { ...baseEnv, PATH: '' };
+  const res = await runNode([join(rootDir, 'scripts', 'worktrees.mjs'), 'archive', 'pr/test-archive', `--date=${date}`, '--json'], {
+    cwd: rootDir,
+    env: nodeEnv,
+  });
+  assert.equal(res.code, 0, `expected archive exit 0\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  const parsed = JSON.parse(res.stdout);
+  assert.equal(parsed.ok, true, `expected ok=true JSON output\n${res.stdout}`);
+
+  const archivedDir = join(workspaceDir, 'archive', 'worktrees', date, 'pr', 'test-archive');
+  assert.equal(parsed.destDir, archivedDir, `expected destDir in JSON output to match archive path\n${res.stdout}`);
+  const legacyGitFile = await stat(join(archivedDir, '.git.worktree')).catch(() => null);
+  assert.equal(legacyGitFile, null, 'expected .git.worktree to be removed (avoid untracked noise)');
+  const gitStat = await stat(join(archivedDir, '.git'));
+  assert.ok(gitStat.isDirectory(), 'expected archived .git to be a directory (detached repo)');
+
+  const meta = await readFile(join(archivedDir, 'ARCHIVE_META.txt'), 'utf-8');
+  assert.ok(meta.includes('component=happier-ui'), `expected component in ARCHIVE_META.txt\n${meta}`);
+  assert.ok(meta.includes('ref=pr/test-archive'), `expected ref in ARCHIVE_META.txt\n${meta}`);
+
+  const afterStatus = await runOk('git', ['status', '--porcelain'], { cwd: archivedDir, env: baseEnv });
+  assert.ok(afterStatus.stdout.includes('A  staged.txt'), `expected staged file preserved\n${afterStatus.stdout}`);
+  assert.ok(afterStatus.stdout.includes(' M README.md'), `expected modified file preserved\n${afterStatus.stdout}`);
+  assert.ok(afterStatus.stdout.includes('?? untracked.txt'), `expected untracked file preserved\n${afterStatus.stdout}`);
+
+  const list = await runOk('git', ['worktree', 'list', '--porcelain'], { cwd: repoDir, env: baseEnv });
+  assert.ok(!list.stdout.includes(worktreeDir), `expected source repo worktree entry pruned\n${list.stdout}`);
+
+  const branchExists = await runCmd('git', ['show-ref', '--verify', 'refs/heads/pr/test-archive'], { cwd: repoDir, env: baseEnv });
+  assert.notEqual(branchExists.code, 0, 'expected source repo branch deleted');
+});
+
+test('hstack wt archive refuses to break stacks unless --detach-stacks is provided', async (t) => {
+  const { baseEnv, repoDir, storageDir, workspaceDir } = await createArchiveFixture(t, 'happy-stacks-wt-archive-stacks-');
+
+  const worktreeDir = join(workspaceDir, 'pr', 'linked-to-stack');
+  await addWorktree({ repoDir, worktreeDir, branch: 'pr/linked-to-stack', baseEnv });
+  await writeFile(join(worktreeDir, 'untracked.txt'), 'untracked\n', 'utf-8');
+
+  const stackName = 'exp-test';
+  const envPath = join(storageDir, stackName, 'env');
+  await mkdir(dirname(envPath), { recursive: true });
+  await writeFile(envPath, [`HAPPIER_STACK_STACK=${stackName}`, `HAPPIER_STACK_REPO_DIR=${worktreeDir}`, ''].join('\n'), 'utf-8');
+
+  const date = '2000-01-03';
+  const nodeEnv = { ...baseEnv, PATH: '' };
+
+  const denied = await runNode(
+    [join(rootDir, 'scripts', 'worktrees.mjs'), 'archive', 'pr/linked-to-stack', `--date=${date}`],
+    { cwd: rootDir, env: nodeEnv }
+  );
+  assert.notEqual(denied.code, 0, `expected archive to refuse without --detach-stacks\nstdout:\n${denied.stdout}\nstderr:\n${denied.stderr}`);
+
+  const ok = await runNode(
+    [
+      join(rootDir, 'scripts', 'worktrees.mjs'),
+      'archive',
+      'pr/linked-to-stack',
+      `--date=${date}`,
+      '--detach-stacks',
+      '--json',
+    ],
+    { cwd: rootDir, env: nodeEnv }
+  );
+  assert.equal(ok.code, 0, `expected archive to succeed with --detach-stacks\nstdout:\n${ok.stdout}\nstderr:\n${ok.stderr}`);
+
+  const nextEnv = await readFile(envPath, 'utf-8');
+  assert.ok(!nextEnv.includes('HAPPIER_STACK_REPO_DIR='), `expected stack env to detach from worktree\n${nextEnv}`);
+
+  const archivedDir = join(workspaceDir, 'archive', 'worktrees', date, 'pr', 'linked-to-stack');
+  const gitStat = await stat(join(archivedDir, '.git'));
+  assert.ok(gitStat.isDirectory(), 'expected archived .git to be a directory (detached repo)');
+});
+
+test('hstack wt archive can archive a broken git worktree (missing .git/worktrees entry)', async (t) => {
+  const { baseEnv, repoDir, workspaceDir } = await createArchiveFixture(t, 'happy-stacks-wt-archive-broken-');
+
+  const worktreeDir = join(workspaceDir, 'pr', 'broken-worktree');
+  await addWorktree({ repoDir, worktreeDir, branch: 'pr/broken-worktree', baseEnv });
+
+  // Create uncommitted changes (no staging; the index will be deleted when we break the worktree).
+  await writeFile(join(worktreeDir, 'untracked.txt'), 'untracked\n', 'utf-8');
+  await writeFile(join(worktreeDir, 'README.md'), 'hello\nchanged\n', 'utf-8');
+
+  // Simulate a corrupted linked worktree by removing its gitdir entry from the source repo.
+  const gitFile = await readFile(join(worktreeDir, '.git'), 'utf-8');
+  const gitdirLine = gitFile
+    .split('\n')
+    .map((l) => l.trim())
+    .find((l) => l.startsWith('gitdir:'));
+  assert.ok(gitdirLine, `expected .git file to include gitdir line\n${gitFile}`);
+  const gitdir = gitdirLine.slice('gitdir:'.length).trim();
+  assert.ok(gitdir, `expected gitdir path\n${gitFile}`);
+  // Use an absolute path so we can rm it reliably.
+  const gitdirAbs = gitdir.startsWith('/') ? gitdir : join(worktreeDir, gitdir);
+  await rm(gitdirAbs, { recursive: true, force: true });
+
+  const date = '2000-01-05';
+  const nodeEnv = { ...baseEnv, PATH: '' };
+  const res = await runNode([join(rootDir, 'scripts', 'worktrees.mjs'), 'archive', 'pr/broken-worktree', `--date=${date}`, '--json'], {
+    cwd: rootDir,
+    env: nodeEnv,
+  });
+  assert.equal(res.code, 0, `expected archive exit 0\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  const parsed = JSON.parse(res.stdout);
+  assert.equal(parsed.ok, true, `expected ok=true JSON output\n${res.stdout}`);
+  assert.equal(parsed.branch, 'pr/broken-worktree', 'expected branch name to be preserved');
+
+  const archivedDir = join(workspaceDir, 'archive', 'worktrees', date, 'pr', 'broken-worktree');
+  const gitStat = await stat(join(archivedDir, '.git'));
+  assert.ok(gitStat.isDirectory(), 'expected archived .git to be a directory (detached repo)');
+
+  const afterStatus = await runOk('git', ['status', '--porcelain'], { cwd: archivedDir, env: baseEnv });
+  assert.ok(afterStatus.stdout.includes(' M README.md'), `expected modified file preserved\n${afterStatus.stdout}`);
+  assert.ok(afterStatus.stdout.includes('?? untracked.txt'), `expected untracked file preserved\n${afterStatus.stdout}`);
+});

package/scripts/worktrees_cursor_monorepo_root.test.mjs

@@ -0,0 +1,23 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { createMonorepoWorktreeEnv, createMonorepoWorktreeFixture, runNode } from './testkit/worktrees_monorepo_testkit.mjs';
+
+test('hstack wt cursor opens the monorepo root (not a subpackage dir) in monorepo worktrees', async (t) => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const { homeDir, monoRoot, sandboxDir, workspaceDir } = await createMonorepoWorktreeFixture(t, {
+    prefix: 'happy-stacks-wt-cursor-mono-',
+  });
+  const env = createMonorepoWorktreeEnv({ homeDir, workspaceDir, sandboxDir });
+
+  const res = await runNode([join(rootDir, 'scripts', 'worktrees.mjs'), 'cursor', 'tmp/mono-wt', '--json'], {
+    cwd: rootDir,
+    env,
+  });
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  const parsed = JSON.parse(res.stdout);
+  assert.equal(parsed.dir, monoRoot);
+});

package/scripts/worktrees_list_specs_no_recurse.test.mjs

@@ -0,0 +1,32 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { listWorktreeSpecs } from './utils/git/worktrees.mjs';
+
+test('listWorktreeSpecs does not recurse into worktree roots', async () => {
+  const tmp = await mkdtemp(join(tmpdir(), 'happier-stack-list-wt-specs-'));
+  try {
+    const workspaceDir = join(tmp, 'workspace');
+    const env = { ...process.env, HAPPIER_STACK_WORKSPACE_DIR: workspaceDir, HAPPIER_STACK_OWNER: 'test' };
+    const rootDir = tmp;
+
+    const wtRoot = join(workspaceDir, 'tmp', 'test', 'mono-wt');
+    await mkdir(wtRoot, { recursive: true });
+    await writeFile(join(wtRoot, '.git'), 'gitdir: dummy\n', 'utf-8');
+
+    // If listWorktreeSpecs incorrectly recurses into worktree roots, it would discover this nested ".git"
+    // and return an extra spec.
+    const nested = join(wtRoot, 'nested');
+    await mkdir(nested, { recursive: true });
+    await writeFile(join(nested, '.git'), 'gitdir: dummy\n', 'utf-8');
+
+    const specs = await listWorktreeSpecs({ rootDir, component: 'happier-ui', env });
+    assert.ok(specs.includes('tmp/mono-wt'), specs.join('\n'));
+    assert.ok(!specs.includes('tmp/mono-wt/nested'), specs.join('\n'));
+  } finally {
+    await rm(tmp, { recursive: true, force: true });
+  }
+});

package/scripts/worktrees_monorepo_testkit.test.mjs

@@ -0,0 +1,29 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { runNode } from './testkit/worktrees_monorepo_testkit.mjs';
+
+test('runNode reports non-zero exit code for signal-terminated process', async () => {
+  const res = await runNode(['-e', 'process.kill(process.pid, "SIGTERM")'], {
+    cwd: process.cwd(),
+    env: process.env,
+  });
+
+  assert.equal(res.code, 1);
+  assert.match(res.stderr, /signal/i);
+});
+
+test('runNode waits for stdio streams to flush before resolving', async () => {
+  const size = 200_000;
+  const res = await runNode(
+    ['-e', `process.stdout.write("A".repeat(${size})); process.stderr.write("B".repeat(${size}));`],
+    {
+      cwd: process.cwd(),
+      env: process.env,
+    }
+  );
+
+  assert.equal(res.code, 0);
+  assert.equal(res.stdout.length, size);
+  assert.equal(res.stderr.length, size);
+});

package/scripts/worktrees_monorepo_use_group.test.mjs

@@ -0,0 +1,41 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { createMonorepoWorktreeEnv, createMonorepoWorktreeFixture, runNode } from './testkit/worktrees_monorepo_testkit.mjs';
+
+test('hstack wt use switches all monorepo group components when target is a monorepo worktree', async (t) => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const { homeDir, monoRoot, sandboxDir, tmp, workspaceDir } = await createMonorepoWorktreeFixture(t, {
+    prefix: 'happy-stacks-wt-use-mono-',
+  });
+  const envFile = join(tmp, 'env');
+  await writeFile(envFile, '', 'utf-8');
+
+  const env = createMonorepoWorktreeEnv({
+    homeDir,
+    workspaceDir,
+    sandboxDir,
+    extraEnv: {
+      HAPPIER_STACK_STACK: 'exp',
+      HAPPIER_STACK_ENV_FILE: envFile,
+    },
+  });
+
+  const res = await runNode(
+    [join(rootDir, 'scripts', 'worktrees.mjs'), 'use', 'tmp/mono-wt', '--force', '--json'],
+    { cwd: rootDir, env }
+  );
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  const parsed = JSON.parse(res.stdout);
+  assert.equal(parsed.repoDir, monoRoot);
+  assert.equal(parsed.activeDir, monoRoot);
+
+  const contents = await readFile(envFile, 'utf-8');
+  assert.ok(contents.includes(`HAPPIER_STACK_REPO_DIR=${monoRoot}\n`), contents);
+  assert.ok(!contents.includes('HAPPIER_STACK_COMPONENT_DIR_'), contents);
+});