@ulysses-ai/create-workspace 0.13.0-beta.2 → 0.14.0-beta.3

package/template/.claude/scripts/build-shared-context-index.test.mjs

@@ -0,0 +1,318 @@
+#!/usr/bin/env node
+// Unit tests for build-shared-context-index.mjs
+// Run: node template/.claude/scripts/build-shared-context-index.test.mjs
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { buildEntries, renderIndex, fingerprint, readDescription } from './build-shared-context-index.mjs';
+
+let failed = 0;
+let passed = 0;
+
+function assert(cond, msg) {
+  if (cond) { passed++; } else { failed++; console.error(`  FAIL: ${msg}`); }
+}
+
+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 setupFixture() {
+  const root = mkdtempSync(join(tmpdir(), 'sc-index-test-'));
+  mkdirSync(join(root, 'shared-context'), { recursive: true });
+  mkdirSync(join(root, 'shared-context', 'locked'), { recursive: true });
+  mkdirSync(join(root, 'shared-context', 'alice'), { recursive: true });
+  return root;
+}
+
+function cleanup(root) {
+  rmSync(root, { recursive: true, force: true });
+}
+
+console.log('# readDescription priority');
+
+{
+  const root = setupFixture();
+  writeFileSync(
+    join(root, 'shared-context', 'with-fm.md'),
+    `---
+state: locked
+type: reference
+description: Frontmatter description wins.
+updated: 2026-04-25
+---
+
+# Title
+
+This is the body.
+`,
+  );
+  const desc = readDescription(join(root, 'shared-context', 'with-fm.md'));
+  assertEq(desc, 'Frontmatter description wins.', 'frontmatter description preferred');
+  cleanup(root);
+}
+
+{
+  const root = setupFixture();
+  writeFileSync(
+    join(root, 'shared-context', 'no-fm-desc.md'),
+    `---
+state: ephemeral
+type: braindump
+updated: 2026-04-25
+---
+
+# Some Title
+
+This is the first paragraph that should be used. It has multiple sentences.
+
+This is a second paragraph.
+`,
+  );
+  const desc = readDescription(join(root, 'shared-context', 'no-fm-desc.md'));
+  assertEq(desc, 'This is the first paragraph that should be used.', 'first sentence fallback');
+  cleanup(root);
+}
+
+{
+  const root = setupFixture();
+  writeFileSync(
+    join(root, 'shared-context', 'no-frontmatter.md'),
+    `# Bare File
+
+Content without frontmatter at all.
+`,
+  );
+  const desc = readDescription(join(root, 'shared-context', 'no-frontmatter.md'));
+  assertEq(desc, 'Content without frontmatter at all.', 'works without frontmatter');
+  cleanup(root);
+}
+
+{
+  const root = setupFixture();
+  writeFileSync(join(root, 'shared-context', 'empty-body.md'), `---
+type: index
+---
+`);
+  const desc = readDescription(join(root, 'shared-context', 'empty-body.md'));
+  assertEq(desc, 'empty body', 'filename slug fallback');
+  cleanup(root);
+}
+
+console.log('# buildEntries grouping & sort');
+
+{
+  const root = setupFixture();
+  writeFileSync(
+    join(root, 'shared-context', 'locked', 'project-status.md'),
+    `---
+description: Project status here.
+---
+
+body
+`,
+  );
+  writeFileSync(
+    join(root, 'shared-context', 'locked', 'naming.md'),
+    `---
+description: Naming convention.
+---
+
+body
+`,
+  );
+  writeFileSync(
+    join(root, 'shared-context', 'inventory.md'),
+    `---
+description: Top-level inventory.
+---
+
+body
+`,
+  );
+  writeFileSync(
+    join(root, 'shared-context', 'alice', 'notes.md'),
+    `---
+description: Alice notes.
+---
+
+body
+`,
+  );
+
+  const entries = buildEntries(root);
+  assertEq(entries.length, 4, '4 entries');
+  assertEq(entries[0].group, 'locked', 'locked first');
+  assertEq(entries[0].sortKey, 'naming.md', 'alphabetical within locked (naming before project)');
+  assertEq(entries[1].sortKey, 'project-status.md', 'second locked entry');
+  assertEq(entries[2].group, '__root__', 'root group second');
+  assertEq(entries[3].group, 'alice', 'user dir last');
+
+  cleanup(root);
+}
+
+console.log('# renderIndex output');
+
+{
+  const entries = [
+    { group: 'locked', sortKey: 'a.md', relativePath: 'locked/a.md', description: 'A.' },
+    { group: '__root__', sortKey: 'b.md', relativePath: 'b.md', description: 'B.' },
+    { group: 'alice', sortKey: 'c.md', relativePath: 'alice/c.md', description: 'C.' },
+  ];
+  const output = renderIndex(entries, '2026-04-25T00:00:00Z');
+  assert(output.includes('## Locked (team truths, always loaded)'), 'has locked heading');
+  assert(output.includes('## Team-shared (root)'), 'has team-shared heading');
+  assert(output.includes('## alice'), 'has user dir heading');
+  assert(output.includes('- [locked/a.md](locked/a.md) — A.'), 'links use relative path');
+  assert(output.includes('generated: 2026-04-25T00:00:00Z'), 'frontmatter has generated timestamp');
+}
+
+{
+  const output = renderIndex([], '2026-04-25T00:00:00Z');
+  assert(output.includes('_(no shared-context files yet)_'), 'empty state');
+}
+
+console.log('# fingerprint ignores generated line');
+
+{
+  const a = `---
+type: index
+generated: 2026-04-25T00:00:00Z
+---
+
+body
+`;
+  const b = `---
+type: index
+generated: 2026-04-26T00:00:00Z
+---
+
+body
+`;
+  assertEq(fingerprint(a), fingerprint(b), 'different generated, same body → same fingerprint');
+}
+
+{
+  const a = `---
+generated: 2026-04-25T00:00:00Z
+---
+
+body one
+`;
+  const b = `---
+generated: 2026-04-25T00:00:00Z
+---
+
+body two
+`;
+  assert(fingerprint(a) !== fingerprint(b), 'different body → different fingerprint');
+}
+
+console.log('# missing shared-context dir');
+
+{
+  const root = mkdtempSync(join(tmpdir(), 'sc-index-empty-'));
+  const entries = buildEntries(root);
+  assertEq(entries, [], 'no shared-context dir yields empty entries');
+  cleanup(root);
+}
+
+console.log('# .indexignore prefix excludes');
+
+{
+  const root = setupFixture();
+  mkdirSync(join(root, 'shared-context', 'archive'), { recursive: true });
+  writeFileSync(
+    join(root, 'shared-context', 'archive', 'old1.md'),
+    `---
+description: Archived 1.
+---
+body
+`,
+  );
+  writeFileSync(
+    join(root, 'shared-context', 'archive', 'old2.md'),
+    `---
+description: Archived 2.
+---
+body
+`,
+  );
+  writeFileSync(
+    join(root, 'shared-context', 'live.md'),
+    `---
+description: Live file.
+---
+body
+`,
+  );
+  writeFileSync(join(root, 'shared-context', '.indexignore'), 'archive/\n# comment\n\n');
+
+  const entries = buildEntries(root);
+  assertEq(entries.length, 1, 'archive/ excluded by .indexignore');
+  assertEq(entries[0].relativePath, 'live.md', 'only live.md survives');
+  cleanup(root);
+}
+
+{
+  const root = setupFixture();
+  writeFileSync(
+    join(root, 'shared-context', 'a.md'),
+    `---
+description: A.
+---
+body
+`,
+  );
+  writeFileSync(
+    join(root, 'shared-context', 'b.md'),
+    `---
+description: B.
+---
+body
+`,
+  );
+  writeFileSync(join(root, 'shared-context', '.indexignore'), 'a.md\n');
+  const entries = buildEntries(root);
+  assertEq(entries.length, 1, 'specific file excluded by .indexignore');
+  assertEq(entries[0].relativePath, 'b.md', 'only b.md survives');
+  cleanup(root);
+}
+
+console.log('# index.md is excluded from its own entries');
+
+{
+  const root = setupFixture();
+  writeFileSync(
+    join(root, 'shared-context', 'index.md'),
+    `---
+type: index
+---
+
+# index
+`,
+  );
+  writeFileSync(
+    join(root, 'shared-context', 'real.md'),
+    `---
+description: Real file.
+---
+
+body
+`,
+  );
+  const entries = buildEntries(root);
+  assertEq(entries.length, 1, 'only the non-index file');
+  assertEq(entries[0].relativePath, 'real.md', 'index.md excluded');
+  cleanup(root);
+}
+
+console.log('');
+console.log(`${passed} passed, ${failed} failed`);
+process.exit(failed > 0 ? 1 : 0);

package/template/.claude/scripts/migrate-claude-md-freshness-include.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+// Idempotent migrator: ensures CLAUDE.md includes @local-only-template-freshness.md.
+// Appends one line at end if missing. Preserves the rest of the file byte-for-byte.
+//
+// Run standalone: node .claude/scripts/migrate-claude-md-freshness-include.mjs
+// Or import { runMigration } and call programmatically.
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join, dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+const INCLUDE_LINE = '@local-only-template-freshness.md';
+
+export function runMigration({ workspaceRoot }) {
+  const path = join(workspaceRoot, 'CLAUDE.md');
+  if (!existsSync(path)) return { action: 'skipped', reason: 'no-claude-md' };
+  const before = readFileSync(path, 'utf-8');
+  if (before.includes(INCLUDE_LINE)) return { action: 'unchanged' };
+  const after = before.endsWith('\n') ? before + INCLUDE_LINE + '\n' : before + '\n' + INCLUDE_LINE + '\n';
+  writeFileSync(path, after);
+  return { action: 'appended' };
+}
+
+// CLI entry point — workspace root is two levels up from this file
+// (.claude/scripts/migrate-... → workspace root).
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const root = resolve(here, '..', '..');
+  const result = runMigration({ workspaceRoot: root });
+  console.log(JSON.stringify(result));
+}

package/template/.claude/scripts/migrate-claude-md-freshness-include.test.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+// Unit tests for migrate-claude-md-freshness-include.mjs
+// Run: node template/.claude/scripts/migrate-claude-md-freshness-include.test.mjs
+import { runMigration } from './migrate-claude-md-freshness-include.mjs';
+import { mkdtempSync, rmSync, writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+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 withTemp(fn) {
+  const dir = mkdtempSync(join(tmpdir(), 'claude-md-mig-'));
+  try { fn(dir); } finally { rmSync(dir, { recursive: true, force: true }); }
+}
+
+console.log('# migrate-claude-md-freshness-include');
+
+// CLAUDE.md missing → no-op
+withTemp((dir) => {
+  const result = runMigration({ workspaceRoot: dir });
+  assertEq(result.action, 'skipped', 'no CLAUDE.md is skipped');
+});
+
+// CLAUDE.md missing the include → appended
+withTemp((dir) => {
+  const path = join(dir, 'CLAUDE.md');
+  writeFileSync(path, '# Workspace\n@workspace.json\n');
+  const result = runMigration({ workspaceRoot: dir });
+  assertEq(result.action, 'appended', 'missing line is appended');
+  const after = readFileSync(path, 'utf-8');
+  assertEq(after.includes('@local-only-template-freshness.md'), true, 'line present after migration');
+});
+
+// CLAUDE.md already has the include → no-op
+withTemp((dir) => {
+  const path = join(dir, 'CLAUDE.md');
+  const original = '# Workspace\n@workspace.json\n@local-only-template-freshness.md\n';
+  writeFileSync(path, original);
+  const result = runMigration({ workspaceRoot: dir });
+  assertEq(result.action, 'unchanged', 'already-present line is unchanged');
+  assertEq(readFileSync(path, 'utf-8'), original, 'file content unchanged');
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed > 0 ? 1 : 0);

package/template/.claude/scripts/sync-tasks.mjs

@@ -0,0 +1,234 @@
+// Mirror TodoWrite ↔ session.md ## Tasks section.
+// Round-trips a flat task list across chats by persisting it on the session branch.
+
+import { readFileSync, writeFileSync, renameSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { readSessionFile } from '../lib/session-frontmatter.mjs';
+import { createTracker } from './trackers/interface.mjs';
+
+const IRREGULARS = {
+  // Pre-built map for verbs whose gerund isn't a clean suffix transform.
+  // Add entries as needed; the rule of thumb is "if the test catches it, fix here".
+};
+
+export function toActiveForm(content) {
+  const trimmed = content.trim();
+  const firstSpace = trimmed.indexOf(' ');
+  const verb = firstSpace === -1 ? trimmed : trimmed.slice(0, firstSpace);
+  const rest = firstSpace === -1 ? '' : trimmed.slice(firstSpace);
+
+  const lower = verb.toLowerCase();
+  if (IRREGULARS[lower]) return IRREGULARS[lower] + rest;
+
+  let gerund;
+  if (verb.endsWith('e') && !verb.endsWith('ee')) {
+    gerund = verb.slice(0, -1) + 'ing';
+  } else if (
+    verb.length >= 3 &&
+    /[aeiou]/.test(verb[verb.length - 2]) &&
+    !/[aeiouwxy]/.test(verb[verb.length - 1])
+  ) {
+    // CVC pattern → double the final consonant (Run → Running)
+    // Skip when ending in w/x/y (Show → Showing, Fix → Fixing).
+    gerund = verb + verb[verb.length - 1] + 'ing';
+  } else {
+    gerund = verb + 'ing';
+  }
+
+  return gerund + rest;
+}
+
+const TASKS_HEADING = '## Tasks';
+const LINK_PREFIX = '> Linked:';
+
+export function parseTasksSection(sessionMdContent) {
+  const lines = sessionMdContent.split('\n');
+  const startIdx = lines.findIndex(l => l.trim() === TASKS_HEADING);
+  if (startIdx === -1) return { linked: null, todos: [] };
+
+  // Section runs until the next "## " heading or EOF.
+  let endIdx = lines.length;
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    if (lines[i].startsWith('## ')) { endIdx = i; break; }
+  }
+
+  const sectionLines = lines.slice(startIdx + 1, endIdx);
+  let linked = null;
+  const todos = [];
+
+  for (const line of sectionLines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    if (trimmed.startsWith(LINK_PREFIX)) {
+      const rest = trimmed.slice(LINK_PREFIX.length).trim();
+      const dashIdx = rest.indexOf(' — ');
+      if (dashIdx === -1) {
+        linked = { id: rest, title: null };
+      } else {
+        linked = { id: rest.slice(0, dashIdx).trim(), title: rest.slice(dashIdx + 3).trim() };
+      }
+      continue;
+    }
+
+    const checkboxMatch = trimmed.match(/^- \[([ x\-])\] (.+)$/);
+    if (checkboxMatch) {
+      const marker = checkboxMatch[1];
+      const status = marker === 'x' ? 'completed' : marker === '-' ? 'in_progress' : 'pending';
+      const content = checkboxMatch[2].trim();
+      todos.push({ content, activeForm: toActiveForm(content), status });
+    }
+  }
+
+  return { linked, todos };
+}
+
+const START_BOOKEND = { content: 'Start work', activeForm: 'Starting work', status: 'completed' };
+const END_BOOKEND   = { content: 'Complete work', activeForm: 'Completing work', status: 'pending' };
+
+export function enforceBookends(todos) {
+  const middle = [];
+  let foundStart = null;
+  let foundEnd = null;
+  for (const t of todos) {
+    if (t.content === 'Start work') foundStart = t;
+    else if (t.content === 'Complete work') foundEnd = t;
+    else middle.push(t);
+  }
+  return [
+    foundStart || { ...START_BOOKEND },
+    ...middle,
+    foundEnd || { ...END_BOOKEND },
+  ];
+}
+
+export function renderTasksSection({ linked, todos }) {
+  const safe = enforceBookends(todos);
+  const lines = ['## Tasks', ''];
+  if (linked) {
+    if (linked.title) {
+      lines.push(`> Linked: ${linked.id} — ${linked.title}`);
+    } else {
+      lines.push(`> Linked: ${linked.id}`);
+    }
+    lines.push('');
+  }
+  for (const t of safe) {
+    const box = t.status === 'completed' ? '[x]' : t.status === 'in_progress' ? '[-]' : '[ ]';
+    lines.push(`- ${box} ${t.content}`);
+  }
+  lines.push('');
+  return lines.join('\n');
+}
+
+export function writeTasksToSession(filePath, taskState) {
+  const original = readFileSync(filePath, 'utf-8');
+  const newSection = renderTasksSection(taskState);
+  const updated = spliceTasksSection(original, newSection);
+
+  // Atomic write: temp file in same dir + rename.
+  const tmp = filePath + '.tmp-sync-tasks';
+  writeFileSync(tmp, updated);
+  renameSync(tmp, filePath);
+}
+
+function spliceTasksSection(content, newSection) {
+  const lines = content.split('\n');
+  const startIdx = lines.findIndex(l => l.trim() === '## Tasks');
+
+  if (startIdx === -1) {
+    // Insert before ## Progress if present, else append before EOF.
+    const progressIdx = lines.findIndex(l => l.trim() === '## Progress');
+    if (progressIdx !== -1) {
+      const before = lines.slice(0, progressIdx).join('\n').replace(/\n+$/, '\n');
+      const after = lines.slice(progressIdx).join('\n');
+      return before + '\n' + newSection + '\n' + after;
+    }
+    // No Progress section — append at end.
+    return content.replace(/\n*$/, '\n\n') + newSection;
+  }
+
+  // Find end of existing ## Tasks section (next ## heading or EOF).
+  let endIdx = lines.length;
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    if (lines[i].startsWith('## ')) { endIdx = i; break; }
+  }
+
+  const before = lines.slice(0, startIdx).join('\n');
+  const after = endIdx < lines.length ? lines.slice(endIdx).join('\n') : '';
+  const beforeTrimmed = before.replace(/\n+$/, '\n');
+  return beforeTrimmed + '\n' + newSection + (after ? '\n' + after : '');
+}
+
+export async function resolveLinked(filePath, { tracker } = {}) {
+  const { fields } = readSessionFile(filePath);
+  if (!fields.workItem) return null;
+  const id = fields.workItem;
+  if (!tracker) return { id, title: null };
+  try {
+    const issue = await tracker.getIssue(id);
+    return { id, title: issue?.title || null };
+  } catch {
+    return { id, title: null };
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const mode = args[0];
+  const filePath = args[1];
+
+  if (!mode || !filePath || (mode !== '--read' && mode !== '--write')) {
+    console.error('Usage: sync-tasks.mjs --read|--write <session.md>');
+    process.exit(2);
+  }
+
+  let fields;
+  try {
+    fields = readSessionFile(filePath).fields;
+  } catch (e) {
+    console.error(`Not a session file: ${e.message}`);
+    process.exit(2);
+  }
+  if (fields.type !== 'session-tracker') {
+    console.error(`Not a session-tracker file (type=${fields.type})`);
+    process.exit(2);
+  }
+
+  let tracker = null;
+  try {
+    const ws = JSON.parse(readFileSync('workspace.json', 'utf-8'));
+    if (ws.workspace?.tracker) tracker = createTracker(ws.workspace.tracker);
+  } catch {
+    // No workspace.json or no tracker configured — skip.
+  }
+
+  if (mode === '--read') {
+    const content = readFileSync(filePath, 'utf-8');
+    const parsed = parseTasksSection(content);
+    if (!parsed.linked) {
+      parsed.linked = await resolveLinked(filePath, { tracker });
+    }
+    process.stdout.write(JSON.stringify(parsed, null, 2) + '\n');
+    return;
+  }
+
+  const stdin = await readStdin();
+  const input = JSON.parse(stdin);
+  const linked = input.linked ?? await resolveLinked(filePath, { tracker });
+  writeTasksToSession(filePath, { linked, todos: input.todos || [] });
+}
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', chunk => { data += chunk; });
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', reject);
+  });
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  main().catch(e => { console.error(e); process.exit(1); });
+}