@shipers-dev/multi 0.12.0 → 0.13.0

package/src/materializer.ts

@@ -1,166 +0,0 @@
-// Materialize agents + skills onto disk so claude-code (and the agent itself
-// via Read/Bash) can load them. Pulls /api/devices/:id/agent_bundle on demand
-// (heartbeat revision mismatch), writes to ~/.multi/skills/<slug>/ and ~/.multi/agents/,
-// then symlinks/copies into ~/.claude/{skills,agents} marked with .multi-managed
-// so we never clobber a user-authored skill or agent definition.
-
-import { mkdirSync, existsSync, writeFileSync, readFileSync, rmSync, symlinkSync, readdirSync, statSync, lstatSync } from 'fs';
-import { join, dirname } from 'path';
-import { apiClient } from './client';
-
-const HOME = process.env.HOME || process.env.USERPROFILE || '.';
-const MULTI_DIR = join(HOME, '.multi');
-const MULTI_SKILLS = join(MULTI_DIR, 'skills');
-const MULTI_AGENTS = join(MULTI_DIR, 'agents');
-const STATE_PATH = join(MULTI_DIR, 'materialized.json');
-const CLAUDE_DIR = join(HOME, '.claude');
-const CLAUDE_SKILLS = join(CLAUDE_DIR, 'skills');
-const CLAUDE_AGENTS = join(CLAUDE_DIR, 'agents');
-const MARKER = '.multi-managed';
-
-type BundleSkill = {
-  id: string;
-  name: string;
-  version: string | null;
-  description: string | null;
-  body: string | null;
-  files: { path: string; content: string }[];
-};
-
-type BundleAgent = {
-  id: string;
-  name: string;
-  type: string;
-  prompt: string | null;
-  approval_status: string;
-  allowed_tools: string | null;
-};
-
-type Bundle = {
-  revision: number;
-  agents: BundleAgent[];
-  skills: BundleSkill[];
-  links: { agent_id: string; skill_id: string }[];
-};
-
-type State = {
-  revision: number;
-  skill_slugs: string[];
-  agent_slugs: string[];
-};
-
-function slugify(s: string): string {
-  return s.toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 64) || 'unnamed';
-}
-
-function loadState(): State {
-  try { return JSON.parse(readFileSync(STATE_PATH, 'utf8')); }
-  catch { return { revision: -1, skill_slugs: [], agent_slugs: [] }; }
-}
-
-function saveState(s: State) {
-  mkdirSync(MULTI_DIR, { recursive: true });
-  writeFileSync(STATE_PATH, JSON.stringify(s, null, 2));
-}
-
-function safeRmManaged(path: string) {
-  if (!existsSync(path)) return;
-  try {
-    const st = lstatSync(path);
-    if (st.isSymbolicLink()) { rmSync(path); return; }
-    if (st.isDirectory() && existsSync(join(path, MARKER))) {
-      rmSync(path, { recursive: true, force: true });
-      return;
-    }
-    if (st.isFile() && path.endsWith('.md')) {
-      const head = readFileSync(path, 'utf8').slice(0, 200);
-      if (head.includes('multi-managed: true')) rmSync(path);
-    }
-  } catch {}
-}
-
-function writeManagedSkill(slug: string, skill: BundleSkill) {
-  const dir = join(MULTI_SKILLS, slug);
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, MARKER), `skill_id=${skill.id}\nrevision=${Date.now()}\n`);
-  if (skill.body) writeFileSync(join(dir, 'SKILL.md'), skill.body);
-  for (const f of skill.files || []) {
-    if (f.path.includes('..') || f.path.startsWith('/')) continue; // path traversal guard
-    if (f.path === MARKER) continue;
-    const out = join(dir, f.path);
-    mkdirSync(dirname(out), { recursive: true });
-    writeFileSync(out, f.content);
-  }
-  // Symlink into ~/.claude/skills/<slug>; replace any prior managed link/dir.
-  mkdirSync(CLAUDE_SKILLS, { recursive: true });
-  const link = join(CLAUDE_SKILLS, slug);
-  safeRmManaged(link);
-  if (!existsSync(link)) {
-    try { symlinkSync(dir, link, 'dir'); } catch {}
-  }
-}
-
-function writeManagedAgent(slug: string, agent: BundleAgent, skillsForAgent: string[]) {
-  if (agent.type !== 'claude-code') return; // acpx agents don't read ~/.claude/agents
-  mkdirSync(CLAUDE_AGENTS, { recursive: true });
-  const out = join(CLAUDE_AGENTS, `${slug}.md`);
-  safeRmManaged(out);
-  const tools = agent.allowed_tools ? `\ntools: ${agent.allowed_tools}` : '';
-  const skillsLine = skillsForAgent.length ? `\nskills: [${skillsForAgent.join(', ')}]` : '';
-  const fm = `---\nname: ${agent.name}\ndescription: managed by multi-agent (id=${agent.id})${tools}${skillsLine}\nmulti-managed: true\n---\n\n`;
-  writeFileSync(out, fm + (agent.prompt || ''));
-}
-
-export async function materializeBundle(apiUrl: string, deviceId: string, log: (m: string) => void): Promise<{ revision: number } | null> {
-  const res = await apiClient.get<Bundle>(`${apiUrl}/api/devices/${deviceId}/agent_bundle`);
-  if (!res.success || !res.data) {
-    log(`materialize: bundle fetch failed: ${res.error || 'unknown'}`);
-    return null;
-  }
-  const bundle = res.data;
-  const prev = loadState();
-
-  const linksByAgent = new Map<string, string[]>();
-  for (const l of bundle.links) {
-    if (!linksByAgent.has(l.agent_id)) linksByAgent.set(l.agent_id, []);
-    linksByAgent.get(l.agent_id)!.push(l.skill_id);
-  }
-
-  const newSkillSlugs: string[] = [];
-  const skillIdToSlug = new Map<string, string>();
-  for (const s of bundle.skills) {
-    const slug = slugify(s.name);
-    skillIdToSlug.set(s.id, slug);
-    writeManagedSkill(slug, s);
-    newSkillSlugs.push(slug);
-  }
-
-  const newAgentSlugs: string[] = [];
-  for (const a of bundle.agents) {
-    const slug = slugify(a.name);
-    const skillSlugs = (linksByAgent.get(a.id) || []).map(id => skillIdToSlug.get(id)).filter(Boolean) as string[];
-    writeManagedAgent(slug, a, skillSlugs);
-    newAgentSlugs.push(slug);
-  }
-
-  // Prune managed entries no longer in bundle.
-  for (const old of prev.skill_slugs) {
-    if (!newSkillSlugs.includes(old)) {
-      safeRmManaged(join(MULTI_SKILLS, old));
-      safeRmManaged(join(CLAUDE_SKILLS, old));
-    }
-  }
-  for (const old of prev.agent_slugs) {
-    if (!newAgentSlugs.includes(old)) {
-      safeRmManaged(join(CLAUDE_AGENTS, `${old}.md`));
-    }
-  }
-
-  saveState({ revision: bundle.revision, skill_slugs: newSkillSlugs, agent_slugs: newAgentSlugs });
-  log(`materialize: revision=${bundle.revision} agents=${bundle.agents.length} skills=${bundle.skills.length}`);
-  return { revision: bundle.revision };
-}
-
-export function lastMaterializedRevision(): number {
-  return loadState().revision;
-}

package/src/worktree.ts

@@ -1,89 +0,0 @@
-// Per-issue git worktree manager. Keeps agent work isolated so parallel runs
-// don't clobber each other. Worktrees live at <workingDir>/.multi/worktrees/<key>
-// on branch multi/<key>, created off the current HEAD of workingDir.
-//
-// No automatic teardown: branch + worktree are kept after done/fail for human
-// review.
-
-import { spawn } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-
-export interface Worktree {
-  path: string;
-  branch: string;
-  created: boolean;
-}
-
-async function run(cwd: string, cmd: string, args: string[]): Promise<{ code: number; stdout: string; stderr: string }> {
-  return await new Promise((resolve) => {
-    const p = spawn(cmd, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
-    let stdout = '';
-    let stderr = '';
-    p.stdout.on('data', (d) => { stdout += d.toString(); });
-    p.stderr.on('data', (d) => { stderr += d.toString(); });
-    p.on('close', (code) => resolve({ code: code ?? 0, stdout: stdout.trim(), stderr: stderr.trim() }));
-    p.on('error', (e) => resolve({ code: 1, stdout: '', stderr: String(e) }));
-  });
-}
-
-export async function isGitRepo(dir: string): Promise<boolean> {
-  if (!existsSync(dir)) return false;
-  const r = await run(dir, 'git', ['rev-parse', '--is-inside-work-tree']);
-  return r.code === 0 && r.stdout === 'true';
-}
-
-async function branchExists(dir: string, branch: string): Promise<boolean> {
-  const r = await run(dir, 'git', ['rev-parse', '--verify', '--quiet', `refs/heads/${branch}`]);
-  return r.code === 0;
-}
-
-function ensureGitignoreEntry(workingDir: string, entry: string): void {
-  const gip = join(workingDir, '.gitignore');
-  let body = '';
-  try { body = existsSync(gip) ? readFileSync(gip, 'utf8') : ''; } catch { body = ''; }
-  const lines = body.split('\n');
-  if (lines.some((l) => l.trim() === entry)) return;
-  const nextBody = (body.endsWith('\n') || body === '' ? body : body + '\n') + entry + '\n';
-  try { writeFileSync(gip, nextBody, 'utf8'); } catch {}
-}
-
-function normalizeKey(issueKey: string): string {
-  return issueKey.toLowerCase().replace(/[^a-z0-9\-_\/]/g, '-');
-}
-
-/**
- * Ensure a worktree exists for this issue. Safe to call repeatedly.
- *
- * - Non-git workingDir: returns { path: workingDir, created: false } (no isolation).
- * - Git workingDir: creates or reuses <workingDir>/.multi/worktrees/<key>
- *   on branch multi/<key>. On failure returns workingDir fallback.
- */
-export async function ensureWorktree(workingDir: string, issueKey: string): Promise<Worktree> {
-  if (!(await isGitRepo(workingDir))) {
-    return { path: workingDir, branch: '', created: false };
-  }
-
-  ensureGitignoreEntry(workingDir, '.multi/');
-
-  const key = normalizeKey(issueKey);
-  const branch = `multi/${key}`;
-  const wtDir = join(workingDir, '.multi', 'worktrees');
-  const wtPath = join(wtDir, key);
-
-  if (existsSync(wtPath)) {
-    return { path: wtPath, branch, created: false };
-  }
-
-  try { mkdirSync(wtDir, { recursive: true }); } catch {}
-
-  const exists = await branchExists(workingDir, branch);
-  const args = exists
-    ? ['worktree', 'add', wtPath, branch]
-    : ['worktree', 'add', '-b', branch, wtPath, 'HEAD'];
-  const r = await run(workingDir, 'git', args);
-  if (r.code !== 0) {
-    throw new Error(`git worktree add failed: ${r.stderr || r.stdout}`);
-  }
-  return { path: wtPath, branch, created: true };
-}