@ulysses-ai/create-workspace 0.13.0-beta.0

package/template/.claude/scripts/migrate-session-layout.mjs

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+// One-shot migrator: move session content from launcher-side paths into
+// each session's workspace worktree, collapse the .gitignore exception
+// block, bump templateVersion, and clean main. Idempotent per session.
+//
+// Exports:
+//   migrateSession(root, sessionName) — per-session branch migration
+//   migrateMain(root) — main-side gitignore + rm --cached + version bump
+//
+// CLI:
+//   node migrate-session-layout.mjs --session-name NAME
+//   node migrate-session-layout.mjs --all
+//   node migrate-session-layout.mjs --main
+//   node migrate-session-layout.mjs --all --main     (runs all sessions then main)
+//   Optional: --root PATH to override auto-detection
+import { execSync } from 'child_process';
+import {
+  readFileSync,
+  writeFileSync,
+  existsSync,
+  readdirSync,
+  copyFileSync,
+  statSync,
+} from 'fs';
+import { join } from 'path';
+import {
+  getWorkspaceRoot,
+  getWorkspacePaths,
+  getMainRoot,
+  readJSON,
+} from '../hooks/_utils.mjs';
+
+export function migrateSession(root, sessionName) {
+  const { workSessionsDir } = getWorkspacePaths(root);
+  const sessionFolder = join(workSessionsDir, sessionName);
+  const worktree = join(sessionFolder, 'workspace');
+
+  if (!existsSync(worktree)) {
+    return { status: 'no-worktree', sessionName };
+  }
+
+  const inWorktreeTracker = join(worktree, 'session.md');
+
+  // Quick idempotency check: if the tracker is already in-worktree AND no
+  // ghosts remain in the branch tree, we're done.
+  if (existsSync(inWorktreeTracker) && listGhostsInBranch(worktree).length === 0) {
+    return { status: 'already-migrated', sessionName };
+  }
+
+  // Copy launcher-side tracker into the worktree (skip if already there)
+  const launcherTracker = join(sessionFolder, 'session.md');
+  if (existsSync(launcherTracker) && !existsSync(inWorktreeTracker)) {
+    copyFileSync(launcherTracker, inWorktreeTracker);
+  }
+
+  // Copy launcher-side specs and plans into the worktree (skip-if-exists)
+  const copiedDocs = [];
+  if (existsSync(sessionFolder)) {
+    for (const entry of readdirSync(sessionFolder)) {
+      if (entry === 'workspace') continue;
+      if (!/^(design|plan)-.*\.md$/.test(entry)) continue;
+      const src = join(sessionFolder, entry);
+      if (!statSync(src).isFile()) continue;
+      const dst = join(worktree, entry);
+      if (!existsSync(dst)) {
+        copyFileSync(src, dst);
+        copiedDocs.push(entry);
+      }
+    }
+  }
+
+  // Stage new files at the top of the worktree
+  const toAdd = [];
+  if (existsSync(inWorktreeTracker)) toAdd.push('session.md');
+  for (const entry of readdirSync(worktree)) {
+    if (/^(design|plan)-.*\.md$/.test(entry)) toAdd.push(entry);
+  }
+  if (toAdd.length > 0) {
+    execSync(`git add ${toAdd.map((f) => `"${f}"`).join(' ')}`, {
+      cwd: worktree,
+      stdio: 'pipe',
+    });
+  }
+
+  // Remove cross-contamination ghosts that this branch inherited from main
+  const ghosts = listGhostsInBranch(worktree);
+  for (const ghost of ghosts) {
+    execSync(`git rm "${ghost}"`, { cwd: worktree, stdio: 'pipe' });
+  }
+
+  // Only commit if there are staged changes
+  const staged = execSync('git diff --cached --name-only', { cwd: worktree })
+    .toString()
+    .trim();
+  if (staged.length === 0) {
+    return { status: 'no-changes', sessionName };
+  }
+  execSync('git commit -m "chore: migrate session content into worktree"', {
+    cwd: worktree,
+    stdio: 'pipe',
+  });
+  return {
+    status: 'migrated',
+    sessionName,
+    added: toAdd,
+    removedGhosts: ghosts,
+    copiedDocs,
+  };
+}
+
+function listGhostsInBranch(worktree) {
+  const out = execSync(
+    'git ls-files "work-sessions/*/session.md" "work-sessions/*/design-*.md" "work-sessions/*/plan-*.md"',
+    { cwd: worktree }
+  ).toString();
+  return out.split('\n').filter(Boolean);
+}
+
+/**
+ * Collapse the "Work sessions" block in .gitignore to a single
+ * `work-sessions/` line. Line-based to avoid regex brittleness against the
+ * multi-line commented version that mentions `work-sessions/**` inline.
+ */
+function collapseGitignoreBlock(content) {
+  const lines = content.split('\n');
+  const startIdx = lines.findIndex((l) => /^# Work sessions\b/.test(l));
+  if (startIdx === -1) {
+    throw new Error('Work sessions block not found in .gitignore');
+  }
+  let endIdx = -1;
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    if (/^!work-sessions\/\*\/plan-\*\.md\s*$/.test(lines[i])) {
+      endIdx = i;
+      break;
+    }
+  }
+  if (endIdx === -1) {
+    throw new Error('End of work-sessions block (!…plan-*.md) not found in .gitignore');
+  }
+  const replacement = [
+    '# Work sessions — the folder is local-only at the workspace root.',
+    "# Session content (tracker, specs, plans) lives inside each session's",
+    '# workspace worktree at the top of the session branch, not on main.',
+    'work-sessions/',
+  ];
+  lines.splice(startIdx, endIdx - startIdx + 1, ...replacement);
+  return lines.join('\n');
+}
+
+export function migrateMain(root) {
+  // Collapse the .gitignore block
+  const gitignorePath = join(root, '.gitignore');
+  const current = readFileSync(gitignorePath, 'utf-8');
+  const collapsed = collapseGitignoreBlock(current);
+  if (collapsed === current) {
+    throw new Error('Gitignore collapse produced no change');
+  }
+  writeFileSync(gitignorePath, collapsed);
+
+  // git rm --cached every launcher-tracked tracker/spec/plan file
+  const listed = execSync(
+    'git ls-files "work-sessions/*/session.md" "work-sessions/*/design-*.md" "work-sessions/*/plan-*.md"',
+    { cwd: root }
+  )
+    .toString()
+    .split('\n')
+    .filter(Boolean);
+  for (const path of listed) {
+    execSync(`git rm --cached "${path}"`, { cwd: root, stdio: 'pipe' });
+  }
+
+  // Bump templateVersion in workspace.json
+  const wsPath = join(root, 'workspace.json');
+  const ws = readJSON(wsPath);
+  if (ws?.workspace) {
+    ws.workspace.templateVersion = '0.9.0';
+    writeFileSync(wsPath, JSON.stringify(ws, null, 2) + '\n');
+  }
+
+  // Stage and commit
+  execSync('git add .gitignore workspace.json', { cwd: root, stdio: 'pipe' });
+  execSync(
+    'git commit -m "chore: migrate workspace to in-worktree session layout"',
+    { cwd: root, stdio: 'pipe' }
+  );
+
+  return { status: 'migrated', removed: listed };
+}
+
+// CLI entry
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  const getArg = (name) => {
+    const i = args.indexOf(`--${name}`);
+    return i >= 0 && args[i + 1] ? args[i + 1] : null;
+  };
+
+  // The script lives in either the launcher's .claude/scripts/ or a session
+  // worktree's .claude/scripts/. getWorkspaceRoot returns the script's
+  // grandparent; when that's a worktree, promote it to the launcher via
+  // the .active-session.json pointer.
+  const inferred = getWorkspaceRoot(import.meta.url);
+  const root = getArg('root') || getMainRoot(inferred);
+
+  const runAll = args.includes('--all');
+  const runMain = args.includes('--main');
+  const name = getArg('session-name');
+
+  const results = {};
+
+  if (runAll) {
+    const { workSessionsDir } = getWorkspacePaths(root);
+    const perSession = [];
+    if (existsSync(workSessionsDir)) {
+      for (const entry of readdirSync(workSessionsDir)) {
+        perSession.push(migrateSession(root, entry));
+      }
+    }
+    results.sessions = perSession;
+  } else if (name) {
+    results.session = migrateSession(root, name);
+  }
+
+  if (runMain) {
+    results.main = migrateMain(root);
+  }
+
+  if (!runAll && !runMain && !name) {
+    console.error(
+      'Usage: migrate-session-layout.mjs (--session-name NAME | --all) [--main] [--root PATH]'
+    );
+    process.exit(1);
+  }
+
+  console.log(JSON.stringify(results, null, 2));
+}

package/template/.claude/scripts/migrate-session-layout.test.mjs

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+// Tests for migrate-session-layout.mjs
+// Run: node .claude/scripts/migrate-session-layout.test.mjs
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, readFileSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import { migrateSession, migrateMain } from './migrate-session-layout.mjs';
+
+let failed = 0;
+let passed = 0;
+
+function assertEq(actual, expected, msg) {
+  const a = JSON.stringify(actual);
+  const e = JSON.stringify(expected);
+  if (a === e) { passed++; }
+  else {
+    failed++;
+    console.error(`  FAIL: ${msg}\n    expected: ${e}\n    actual:   ${a}`);
+  }
+}
+
+function assertTrue(cond, msg) {
+  if (cond) passed++;
+  else { failed++; console.error(`  FAIL: ${msg}`); }
+}
+
+// Spin up a fake workspace with a session worktree on a session branch.
+// Uses real git so we test end-to-end.
+function buildFixture() {
+  const root = mkdtempSync(join(tmpdir(), 'migrator-test-'));
+  execSync('git init -q -b main', { cwd: root });
+  execSync('git config user.email test@example.com', { cwd: root });
+  execSync('git config user.name Test', { cwd: root });
+
+  writeFileSync(join(root, 'workspace.json'), JSON.stringify({
+    workspace: { workSessionsDir: 'work-sessions', templateVersion: '0.8.0' },
+  }, null, 2) + '\n');
+
+  const oldGitignore = [
+    '# Work sessions — the folder and worktrees are local, but the session tracker,',
+    '# specs, and plans are tracked so durable thinking travels across machines.',
+    'work-sessions/**',
+    '!work-sessions/*/',
+    '!work-sessions/*/session.md',
+    '!work-sessions/*/design-*.md',
+    '!work-sessions/*/plan-*.md',
+    '',
+  ].join('\n');
+  writeFileSync(join(root, '.gitignore'), oldGitignore);
+  execSync('git add -A && git commit -q -m "init"', { cwd: root });
+
+  // Session "demo" — tracker + spec exist at launcher-side paths, tracked on main.
+  mkdirSync(join(root, 'work-sessions', 'demo'), { recursive: true });
+  writeFileSync(join(root, 'work-sessions', 'demo', 'session.md'),
+    '---\ntype: session-tracker\nname: demo\nstatus: active\n---\n\nbody\n');
+  writeFileSync(join(root, 'work-sessions', 'demo', 'design-demo.md'),
+    '---\ntopic: demo\n---\n\nspec body\n');
+  execSync('git add work-sessions/demo/session.md work-sessions/demo/design-demo.md && git commit -q -m "add demo tracker and spec"',
+    { cwd: root });
+
+  // Create branch + worktree for demo. Branch inherits the tracker.
+  execSync('git branch feature/demo main', { cwd: root });
+  execSync('git worktree add -q work-sessions/demo/workspace feature/demo', { cwd: root });
+
+  return root;
+}
+
+// migrateSession copies launcher tracker+spec into worktree, removes ghosts,
+// and commits on the session branch.
+{
+  const root = buildFixture();
+  try {
+    const result = migrateSession(root, 'demo');
+    assertEq(result.status, 'migrated', 'first migration returns migrated');
+
+    const inWorktreeTracker = join(root, 'work-sessions', 'demo', 'workspace', 'session.md');
+    assertTrue(existsSync(inWorktreeTracker), 'tracker exists at worktree top');
+
+    const inWorktreeSpec = join(root, 'work-sessions', 'demo', 'workspace', 'design-demo.md');
+    assertTrue(existsSync(inWorktreeSpec), 'spec exists at worktree top');
+
+    const worktree = join(root, 'work-sessions', 'demo', 'workspace');
+    const listed = execSync('git ls-files', { cwd: worktree }).toString();
+    assertTrue(listed.includes('\nsession.md\n') || listed.startsWith('session.md\n'),
+      'top-level session.md is tracked on branch');
+    assertTrue(listed.includes('design-demo.md'),
+      'top-level design-demo.md is tracked on branch');
+    assertTrue(!listed.includes('work-sessions/demo/session.md'),
+      'branch no longer tracks ghost work-sessions/demo/session.md');
+
+    const log = execSync('git log --oneline feature/demo', { cwd: root }).toString();
+    assertTrue(log.includes('migrate session content into worktree'),
+      'branch has migration commit');
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+}
+
+// Idempotency: re-running on an already-migrated session is a no-op.
+{
+  const root = buildFixture();
+  try {
+    migrateSession(root, 'demo');
+    const result = migrateSession(root, 'demo');
+    assertEq(result.status, 'already-migrated', 'second run reports already-migrated');
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+}
+
+// migrateMain updates .gitignore, git rm --cached's tracker paths, bumps
+// templateVersion, and commits on main.
+{
+  const root = buildFixture();
+  try {
+    migrateSession(root, 'demo');
+    const result = migrateMain(root);
+    assertEq(result.status, 'migrated', 'main migration returns migrated');
+
+    const gi = readFileSync(join(root, '.gitignore'), 'utf-8');
+    assertTrue(gi.includes('work-sessions/'), '.gitignore has work-sessions/ line');
+    assertTrue(!gi.includes('!work-sessions/*/session.md'),
+      '.gitignore exception removed');
+
+    const mainTracked = execSync('git ls-files', { cwd: root }).toString();
+    assertTrue(!mainTracked.includes('work-sessions/demo/session.md'),
+      'main no longer tracks work-sessions/demo/session.md');
+    assertTrue(!mainTracked.includes('work-sessions/demo/design-demo.md'),
+      'main no longer tracks work-sessions/demo/design-demo.md');
+
+    const ws = JSON.parse(readFileSync(join(root, 'workspace.json'), 'utf-8'));
+    assertEq(ws.workspace.templateVersion, '0.9.0', 'templateVersion bumped to 0.9.0');
+
+    const mainLog = execSync('git log --oneline main -1', { cwd: root }).toString();
+    assertTrue(mainLog.includes('migrate workspace to in-worktree session layout'),
+      'main has migration commit');
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+}
+
+console.log(`Passed: ${passed}, Failed: ${failed}`);
+if (failed > 0) process.exit(1);

package/template/.claude/scripts/trackers/github-issues.mjs

@@ -0,0 +1,170 @@
+// GitHub Issues adapter. Wraps the `gh` CLI via an injectable spawnFn.
+// Issue IDs are opaque strings of the form "gh:N" — adapters outside this file
+// don't need to parse them; routing is handled by interface.mjs.
+
+import { spawnSync as nodeSpawnSync } from 'node:child_process';
+import { AlreadyAssignedError } from './interface.mjs';
+
+const ISSUE_FIELDS = 'number,title,body,state,assignees,labels,milestone,url,createdAt,updatedAt';
+
+const STANDARD_LABELS = [
+  { name: 'bug', color: 'd73a4a' },
+  { name: 'feat', color: 'a2eeef' },
+  { name: 'chore', color: 'cfd3d7' },
+  { name: 'P1', color: 'b60205' },
+  { name: 'P2', color: 'fbca04' },
+  { name: 'P3', color: '0e8a16' },
+];
+
+export function createGithubAdapter(config, { spawnFn = nodeSpawnSync } = {}) {
+  const repo = resolveRepo(config, spawnFn);
+  let loginCache = null;
+
+  function gh(args, { input } = {}) {
+    const result = spawnFn('gh', args, {
+      input,
+      encoding: 'utf-8',
+      stdio: input !== undefined ? ['pipe', 'pipe', 'pipe'] : ['inherit', 'pipe', 'pipe'],
+    });
+    if (result.status !== 0) {
+      throw new Error(`gh ${args.join(' ')} failed: ${(result.stderr || '').trim()}`);
+    }
+    return result.stdout || '';
+  }
+
+  function getLogin() {
+    if (loginCache) return loginCache;
+    loginCache = gh(['api', 'user', '--jq', '.login']).trim();
+    return loginCache;
+  }
+
+  function normalize(raw) {
+    return {
+      id: `gh:${raw.number}`,
+      number: raw.number,
+      title: raw.title,
+      body: raw.body || '',
+      state: (raw.state || '').toLowerCase() === 'closed' ? 'closed' : 'open',
+      assignees: (raw.assignees || []).map(a => a.login),
+      labels: (raw.labels || []).map(l => l.name),
+      milestone: raw.milestone?.title ?? null,
+      url: raw.url,
+      createdAt: raw.createdAt,
+      updatedAt: raw.updatedAt,
+    };
+  }
+
+  function parseIssueNumber(issueId) {
+    const m = issueId.match(/^gh:(\d+)$/);
+    if (!m) throw new Error(`Not a GitHub issue ID: ${issueId}`);
+    return parseInt(m[1], 10);
+  }
+
+  async function listAssignedToMe() {
+    const me = getLogin();
+    const stdout = gh(['issue', 'list', '--repo', repo, '--assignee', me, '--state', 'open', '--json', ISSUE_FIELDS]);
+    return JSON.parse(stdout).map(normalize);
+  }
+
+  async function listUnassigned() {
+    const stdout = gh(['issue', 'list', '--repo', repo, '--search', 'no:assignee', '--state', 'open', '--json', ISSUE_FIELDS]);
+    return JSON.parse(stdout).map(normalize);
+  }
+
+  async function getIssue(issueId) {
+    const num = parseIssueNumber(issueId);
+    const stdout = gh(['issue', 'view', String(num), '--repo', repo, '--json', ISSUE_FIELDS]);
+    return normalize(JSON.parse(stdout));
+  }
+
+  async function claim(issueId) {
+    const me = getLogin();
+    const issue = await getIssue(issueId);
+    const others = issue.assignees.filter(a => a !== me);
+    if (others.length > 0) {
+      throw new AlreadyAssignedError(issueId, others);
+    }
+    if (!issue.assignees.includes(me)) {
+      gh(['issue', 'edit', String(issue.number), '--repo', repo, '--add-assignee', me]);
+      return getIssue(issueId);
+    }
+    return issue;
+  }
+
+  async function createIssue({ title, body = '', labels = [], milestone = null }) {
+    const args = ['issue', 'create', '--repo', repo, '--title', title, '--body-file', '-'];
+    if (labels.length > 0) args.push('--label', labels.join(','));
+    if (milestone) args.push('--milestone', milestone);
+    const stdout = gh(args, { input: body });
+    const m = stdout.match(/\/issues\/(\d+)/);
+    if (!m) throw new Error(`Could not parse issue number from: ${stdout.trim()}`);
+    return getIssue(`gh:${m[1]}`);
+  }
+
+  async function comment(issueId, body) {
+    const num = parseIssueNumber(issueId);
+    gh(['issue', 'comment', String(num), '--repo', repo, '--body-file', '-'], { input: body });
+  }
+
+  async function closeIssue(issueId, { comment: commentBody } = {}) {
+    const num = parseIssueNumber(issueId);
+    if (commentBody) {
+      gh(['issue', 'comment', String(num), '--repo', repo, '--body-file', '-'], { input: commentBody });
+    }
+    gh(['issue', 'close', String(num), '--repo', repo]);
+  }
+
+  async function ensureLabels() {
+    for (const { name, color } of STANDARD_LABELS) {
+      gh(['label', 'create', name, '--repo', repo, '--color', color, '--force']);
+    }
+  }
+
+  async function ensureMilestone({ title, description = '', dueOn = null } = {}) {
+    if (!title) throw new Error('ensureMilestone: title is required');
+    const listStdout = gh(['api', `repos/${repo}/milestones?state=all&per_page=100`]);
+    const existing = JSON.parse(listStdout).find(m => m.title === title);
+    if (existing) return normalizeMilestone(existing);
+
+    const args = ['api', `repos/${repo}/milestones`, '-X', 'POST', '-f', `title=${title}`];
+    if (description) args.push('-f', `description=${description}`);
+    if (dueOn) args.push('-f', `due_on=${dueOn}`);
+    const created = JSON.parse(gh(args));
+    return normalizeMilestone(created);
+  }
+
+  return {
+    listAssignedToMe,
+    listUnassigned,
+    getIssue,
+    claim,
+    createIssue,
+    comment,
+    closeIssue,
+    ensureLabels,
+    ensureMilestone,
+    get identity() { return `github-issues:${repo}`; },
+  };
+}
+
+function normalizeMilestone(raw) {
+  return {
+    number: raw.number,
+    title: raw.title,
+    description: raw.description || '',
+    state: raw.state, // 'open' | 'closed'
+    dueOn: raw.due_on || null,
+    url: raw.html_url,
+  };
+}
+
+function resolveRepo(config, spawnFn) {
+  if (config.repo && config.repo !== 'auto') return config.repo;
+  const result = spawnFn('git', ['remote', 'get-url', 'origin'], { encoding: 'utf-8' });
+  if (result.status !== 0) {
+    throw new Error(`git remote get-url failed: ${(result.stderr || '').trim()}`);
+  }
+  const m = result.stdout.trim().match(/github\.com[:/]([^/]+)\/([^/.]+?)(?:\.git)?$/);
+  if (!m) throw new Error(`Cannot parse GitHub remote: ${result.stdout.trim()}`);
+  return `${m[1]}/${m[2]}`;
+}