npm - @ulysses-ai/create-workspace - Versions diffs - 0.14.0-beta.3 → 0.15.0-beta.1 - Mend

@ulysses-ai/create-workspace 0.14.0-beta.3 → 0.15.0-beta.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (50) hide show

package/template/.claude/scripts/capture-context.mjs ADDED Viewed

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+// Centralized capture helper for /braindump, /handoff, /aside, /promote.
+// Mechanizes the path math, naming convention, and frontmatter so skills
+// don't have to duplicate it (and can't drift from each other).
+//
+// Usage:
+//   echo "<body>" | node capture-context.mjs \
+//     --type braindump|handoff|research \
+//     --topic kebab-case-slug \
+//     --scope shared|team-member \
+//     [--user alice]            # required when --scope team-member
+//     [--description "..."]     # one-line summary, used by index
+//     [--variant aside]         # arbitrary frontmatter marker
+//     [--local-only]            # prefix filename with local-only- (gitignored)
+//     [--update]                # overwrite if file exists; default appends -2, -3, ...
+//     [--root <path>]           # workspace root (defaults to cwd)
+//     [--print-only]            # don't write; just print the planned path
+//
+// Path layout:
+//   shared scope:      workspace-context/shared/{type}_{topic}.md
+//   team-member scope: workspace-context/team-member/{user}/{type}_{topic}.md
+// With --local-only, the file basename is prefixed `local-only-` (e.g.
+// `local-only-research_my-topic.md`), so the gitignore pattern keeps it
+// out of git.
+//
+// Stdin: the markdown body to write under the frontmatter. Required unless
+// --print-only is passed.
+//
+// Stdout: a single line with the absolute path of the written (or planned) file.
+import { existsSync, mkdirSync, readFileSync, writeFileSync, statSync, realpathSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+function isMainModule(metaUrl) {
+  if (!process.argv[1]) return false;
+  try {
+    return realpathSync(fileURLToPath(metaUrl)) === realpathSync(process.argv[1]);
+  } catch { return false; }
+}
+const VALID_TYPES = new Set(['braindump', 'handoff', 'research']);
+const VALID_SCOPES = new Set(['shared', 'team-member']);
+const WC_DIR = 'workspace-context';
+const SHARED_DIR = 'shared';
+const TEAM_MEMBER_DIR = 'team-member';
+function parseArgs(argv) {
+  const args = {
+    type: null,
+    topic: null,
+    scope: null,
+    user: null,
+    description: null,
+    variant: null,
+    localOnly: false,
+    update: false,
+    root: process.cwd(),
+    printOnly: false,
+  };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--type') args.type = argv[++i];
+    else if (a === '--topic') args.topic = argv[++i];
+    else if (a === '--scope') args.scope = argv[++i];
+    else if (a === '--user') args.user = argv[++i];
+    else if (a === '--description') args.description = argv[++i];
+    else if (a === '--variant') args.variant = argv[++i];
+    else if (a === '--local-only') args.localOnly = true;
+    else if (a === '--update') args.update = true;
+    else if (a === '--root') args.root = argv[++i];
+    else if (a === '--print-only') args.printOnly = true;
+    else throw new Error(`Unknown arg: ${a}`);
+  }
+  return args;
+}
+function validate(args) {
+  if (!args.type || !VALID_TYPES.has(args.type)) {
+    throw new Error(`--type must be one of: ${[...VALID_TYPES].join(', ')}`);
+  }
+  if (!args.topic || !/^[a-z0-9][a-z0-9-]*$/.test(args.topic)) {
+    throw new Error('--topic must be kebab-case (lowercase letters, digits, hyphens)');
+  }
+  if (!args.scope || !VALID_SCOPES.has(args.scope)) {
+    throw new Error(`--scope must be one of: ${[...VALID_SCOPES].join(', ')}`);
+  }
+  if (args.scope === 'team-member' && !args.user) {
+    throw new Error('--user is required when --scope is team-member');
+  }
+  if (args.scope === 'team-member' && !/^[A-Za-z0-9_-]+$/.test(args.user)) {
+    throw new Error('--user must be alphanumeric (with optional - or _)');
+  }
+}
+function computeDir(args) {
+  if (args.scope === 'shared') {
+    return join(args.root, WC_DIR, SHARED_DIR);
+  }
+  return join(args.root, WC_DIR, TEAM_MEMBER_DIR, args.user);
+}
+function computeBaseFilename(args) {
+  const prefix = args.localOnly ? 'local-only-' : '';
+  return `${prefix}${args.type}_${args.topic}.md`;
+}
+function resolveCollision(dir, baseFilename, update) {
+  const initial = join(dir, baseFilename);
+  if (update) return initial;
+  if (!existsSync(initial)) return initial;
+  const dot = baseFilename.lastIndexOf('.');
+  const stem = baseFilename.slice(0, dot);
+  const ext = baseFilename.slice(dot);
+  for (let i = 2; i < 1000; i++) {
+    const candidate = join(dir, `${stem}-${i}${ext}`);
+    if (!existsSync(candidate)) return candidate;
+  }
+  throw new Error(`Could not find unique filename for ${baseFilename} (1000+ collisions)`);
+}
+function todayISO() {
+  return new Date().toISOString().slice(0, 10);
+}
+function buildFrontmatter(args) {
+  const fm = {
+    state: 'ephemeral',
+    lifecycle: 'active',
+    type: args.type,
+    topic: args.topic,
+  };
+  if (args.scope === 'team-member') fm.author = args.user;
+  if (args.variant) fm.variant = args.variant;
+  if (args.description) fm.description = args.description;
+  fm.updated = todayISO();
+  return fm;
+}
+function renderFrontmatter(fm) {
+  const lines = ['---'];
+  for (const [k, v] of Object.entries(fm)) {
+    lines.push(`${k}: ${v}`);
+  }
+  lines.push('---');
+  return lines.join('\n');
+}
+function readStdinSync() {
+  try {
+    return readFileSync(0, 'utf-8');
+  } catch {
+    return '';
+  }
+}
+function ensureDir(dir) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+function plan(args) {
+  validate(args);
+  const dir = computeDir(args);
+  const baseFilename = computeBaseFilename(args);
+  const filePath = resolveCollision(dir, baseFilename, args.update);
+  return { dir, filePath, frontmatter: buildFrontmatter(args) };
+}
+function write(args, body) {
+  const planned = plan(args);
+  ensureDir(planned.dir);
+  const content = renderFrontmatter(planned.frontmatter) + '\n\n' + body.replace(/^\n+/, '');
+  const finalContent = content.endsWith('\n') ? content : content + '\n';
+  writeFileSync(planned.filePath, finalContent);
+  return planned.filePath;
+}
+function main() {
+  const args = parseArgs(process.argv);
+  args.root = resolve(args.root);
+  if (args.printOnly) {
+    const planned = plan(args);
+    process.stdout.write(planned.filePath + '\n');
+    return;
+  }
+  const body = readStdinSync();
+  if (!body || !body.trim()) {
+    throw new Error('No body content on stdin (use --print-only to skip writing)');
+  }
+  const filePath = write(args, body);
+  process.stdout.write(filePath + '\n');
+}
+if (isMainModule(import.meta.url)) {
+  try {
+    main();
+  } catch (err) {
+    process.stderr.write(`capture-context: ${err.message}\n`);
+    process.exit(1);
+  }
+}
+export {
+  parseArgs,
+  validate,
+  computeDir,
+  computeBaseFilename,
+  resolveCollision,
+  buildFrontmatter,
+  renderFrontmatter,
+  plan,
+  write,
+};

package/template/.claude/scripts/generate-claude-local.mjs ADDED Viewed

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+// Write CLAUDE.local.md at the workspace root with the per-user import.
+//
+// CLAUDE.local.md is gitignored — it carries user-scoped context that
+// shouldn't propagate across team members. The single source of identity
+// is `.claude/settings.local.json` → `workspace.user`.
+//
+// Usage:
+//   node generate-claude-local.mjs [--root <path>] [--force]
+//
+// Behavior:
+//   - Reads workspace.user from .claude/settings.local.json
+//   - Refuses to overwrite an existing CLAUDE.local.md unless --force
+//   - Idempotent: same input → same content
+//
+// Exit codes:
+//   0 — wrote (or would have written) the file
+//   1 — error (missing settings, settings missing user, refusal to overwrite)
+import { readFileSync, writeFileSync, existsSync, realpathSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+function isMainModule(metaUrl) {
+  if (!process.argv[1]) return false;
+  try {
+    return realpathSync(fileURLToPath(metaUrl)) === realpathSync(process.argv[1]);
+  } catch { return false; }
+}
+function parseArgs(argv) {
+  const args = { root: process.cwd(), force: false };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--root') args.root = argv[++i];
+    else if (a === '--force') args.force = true;
+    else throw new Error(`Unknown arg: ${a}`);
+  }
+  return args;
+}
+function readWorkspaceUser(root) {
+  const settingsPath = join(root, '.claude', 'settings.local.json');
+  if (!existsSync(settingsPath)) {
+    throw new Error(`Missing ${settingsPath} — run /workspace-init first`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+  } catch (e) {
+    throw new Error(`Could not parse ${settingsPath}: ${e.message}`);
+  }
+  const user = parsed?.workspace?.user;
+  if (!user || typeof user !== 'string') {
+    throw new Error(`workspace.user not set in ${settingsPath}`);
+  }
+  if (!/^[A-Za-z0-9_-]+$/.test(user)) {
+    throw new Error(`workspace.user "${user}" must be alphanumeric (with optional - or _)`);
+  }
+  return user;
+}
+function renderClaudeLocal(user) {
+  return `## My Context
+@workspace-context/team-member/${user}/index.md
+`;
+}
+function generateClaudeLocal(root, { force = false } = {}) {
+  const user = readWorkspaceUser(root);
+  const target = join(root, 'CLAUDE.local.md');
+  const content = renderClaudeLocal(user);
+  if (existsSync(target) && !force) {
+    const existing = readFileSync(target, 'utf-8');
+    if (existing === content) {
+      return { path: target, status: 'unchanged' };
+    }
+    throw new Error(
+      `${target} already exists with different content. Re-run with --force to overwrite.`,
+    );
+  }
+  writeFileSync(target, content);
+  return { path: target, status: existsSync(target) ? 'written' : 'written' };
+}
+function main() {
+  const args = parseArgs(process.argv);
+  const root = resolve(args.root);
+  const result = generateClaudeLocal(root, { force: args.force });
+  process.stdout.write(JSON.stringify(result) + '\n');
+}
+if (isMainModule(import.meta.url)) {
+  try {
+    main();
+  } catch (err) {
+    process.stderr.write(`generate-claude-local: ${err.message}\n`);
+    process.exit(1);
+  }
+}
+export { readWorkspaceUser, renderClaudeLocal, generateClaudeLocal };

package/template/.claude/scripts/migrate-canonical-priority.mjs ADDED Viewed

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+// Idempotent migrator: back-fill `priority: critical` on locked workspace-context
+// files that lack the field. Default-to-critical preserves existing behavior —
+// no surprise drops on upgrade.
+//
+// Usage:
+//   node migrate-canonical-priority.mjs [--root <path>]
+//
+// Walks <root>/workspace-context/shared/locked/*.md. For each file:
+//   - Skip non-.md files and files without parseable frontmatter (warn to stderr).
+//   - If `priority` is already set (any value), leave the file untouched.
+//   - Otherwise add `priority: critical` losslessly via updateSessionContent.
+//
+// Returns { status, files: { applied, unchanged } } where status is 'applied'
+// when at least one file was modified, else 'noop'. Always exits 0 — idempotent
+// migrations don't fail.
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  readdirSync,
+  statSync,
+  realpathSync,
+} from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseSessionContent, updateSessionContent } from '../lib/session-frontmatter.mjs';
+function isMainModule(metaUrl) {
+  if (!process.argv[1]) return false;
+  try {
+    return realpathSync(fileURLToPath(metaUrl)) === realpathSync(process.argv[1]);
+  } catch { return false; }
+}
+function parseArgs(argv) {
+  const args = { root: process.cwd() };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--root') args.root = argv[++i];
+    else throw new Error(`Unknown arg: ${a}`);
+  }
+  return args;
+}
+export function migrateCanonicalPriority({ root }) {
+  const absRoot = resolve(root);
+  const lockedDir = join(absRoot, 'workspace-context', 'shared', 'locked');
+  const files = { applied: [], unchanged: [] };
+  if (!existsSync(lockedDir)) {
+    return { status: 'noop', files };
+  }
+  let entries;
+  try {
+    entries = readdirSync(lockedDir).sort();
+  } catch {
+    return { status: 'noop', files };
+  }
+  for (const name of entries) {
+    if (!name.endsWith('.md')) continue;
+    const full = join(lockedDir, name);
+    let st;
+    try { st = statSync(full); } catch { continue; }
+    if (!st.isFile()) continue;
+    const raw = readFileSync(full, 'utf-8');
+    let parsed;
+    try {
+      parsed = parseSessionContent(raw);
+    } catch {
+      console.error(`warning: skipping ${full}: no parseable frontmatter`);
+      continue;
+    }
+    if (parsed?.fields?.priority !== undefined) {
+      files.unchanged.push(name);
+      continue;
+    }
+    const updated = updateSessionContent(raw, { priority: 'critical' });
+    writeFileSync(full, updated);
+    files.applied.push(name);
+  }
+  return {
+    status: files.applied.length > 0 ? 'applied' : 'noop',
+    files,
+  };
+}
+function main() {
+  const args = parseArgs(process.argv);
+  const result = migrateCanonicalPriority({ root: args.root });
+  process.stdout.write(JSON.stringify(result) + '\n');
+}
+if (isMainModule(import.meta.url)) {
+  try {
+    main();
+  } catch (err) {
+    process.stderr.write(`migrate-canonical-priority: ${err.message}\n`);
+    process.exit(1);
+  }
+}

package/template/.claude/scripts/migrate-open-work.mjs CHANGED Viewed

@@ -67,7 +67,7 @@ for (const ticket of tickets) {
     '',
     '---',
     '',
-    `Migrated from \`shared-context/open-work.md\` ticket #${ticket.id} (status at migration: \`${ticket.status}\`${ticket.branch ? `, branch: \`${ticket.branch}\`` : ''}).`,
+    `Migrated from \`workspace-context/open-work.md\` ticket #${ticket.id} (status at migration: \`${ticket.status}\`${ticket.branch ? `, branch: \`${ticket.branch}\`` : ''}).`,
   ].join('\n');
   const issue = await tracker.createIssue({ title: ticket.title, body, labels, milestone: ticket.milestone });