drafted 1.17.3 → 1.17.5

package/cli/drafted.mjs

@@ -15,6 +15,7 @@ import { homedir, tmpdir, platform } from 'os';
 import { fileURLToPath } from 'url';
 import { createHash } from 'node:crypto';
 import { DESIGN_SYSTEM_PROMPT, buildDesignPrompt } from './prompts.mjs';
+import { scanRepoAgents, detectDefaultBranch, detectRemoteUrl, isGitUrl, cloneToTemp } from './repo-scan.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -2113,4 +2114,120 @@ minionCmd
     emitMinionResult(opts.format, { status: 'ok', id: data.id || id });
   });
 
+// ── repo: register a git repo and index its .agents/ (Causeway seam) ──────
+// org substrate normalization, Move C. The CLI is the seam: it scans a repo's
+// `.agents/skills/<name>/SKILL.md` and `.agents/identities/<slug>/identity.yaml`
+// and POSTs the catalog to /api/repos. Content stays in git; Drafted keeps a
+// read-only index for browse/search. `repo add` is idempotent (re-scan on re-add),
+// so content edits in git are reflected with no pin bump. No Drafted token in the
+// daemon — it shells out to this verb.
+const repoCmd = program.command('repo').description('Registered git repos (org index of .agents/ skills/identities)');
+
+repoCmd
+  .command('add <urlOrPath>')
+  .description('Register a git repo (URL or local path) and ingest its .agents/ skills/identities into the org index')
+  .option('--org <org>', 'resolve against this Drafted org (id or name); scopes per-request without switching the session')
+  .option('--slug <slug>', 'repo slug (defaults to the repo name from the URL)')
+  .option('--description <desc>', 'short description')
+  .option('--branch <branch>', 'default branch (defaults to the checked-out branch, then main)')
+  .option('--format <fmt>', 'output format: json or text', 'text')
+  .action(async (urlOrPath, opts) => {
+    requireLogin();
+    const orgHeaders = opts.org ? { 'X-Drafted-Org': opts.org } : {};
+    // Resolve the source dir to scan + the gitUrl to store.
+    let dir;
+    let cleanup = () => {};
+    let gitUrl;
+    let defaultBranch;
+    if (isGitUrl(urlOrPath)) {
+      try {
+        const c = cloneToTemp(urlOrPath);
+        dir = c.dir; cleanup = c.cleanup;
+      } catch (err) {
+        console.error(`❌ Failed to clone ${urlOrPath}: ${err.message}`);
+        process.exit(1);
+      }
+      gitUrl = urlOrPath;
+      defaultBranch = opts.branch || detectDefaultBranch(dir);
+    } else if (existsSync(urlOrPath)) {
+      dir = resolve(urlOrPath);
+      gitUrl = opts.slug ? undefined : detectRemoteUrl(dir);
+      defaultBranch = opts.branch || detectDefaultBranch(dir);
+    } else {
+      console.error(`❌ Not a git URL and not a local path: ${urlOrPath}`);
+      process.exit(1);
+    }
+    try {
+      const { skills, identities } = scanRepoAgents(dir);
+      const entries = [...skills, ...identities];
+      const payload = {
+        gitUrl: gitUrl || urlOrPath,
+        slug: opts.slug,
+        description: opts.description,
+        defaultBranch,
+        entries,
+      };
+      const server = getServerUrl().replace(/\/$/, '');
+      const res = await authFetch(`${server}/api/repos`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...orgHeaders },
+        body: JSON.stringify(payload),
+      });
+      const data = await res.json().catch(() => ({}));
+      if (!res.ok) {
+        const err = data.error || `HTTP ${res.status}`;
+        if (opts.format === 'json') console.log(JSON.stringify({ ok: false, command: 'repo:add', error: err }));
+        else console.log(['error', err].join('\t'));
+        process.exit(1);
+      }
+      const created = res.status === 201;
+      if (opts.format === 'json') {
+        console.log(JSON.stringify({ ok: true, command: 'repo:add', data: { ...data, created, skills: skills.length, identities: identities.length } }));
+      } else {
+        console.log([created ? 'added' : 'updated', data.slug || '', data.gitUrl || gitUrl || '', data.defaultBranch || defaultBranch, `skills:${skills.length}`, `identities:${identities.length}`].join('\t'));
+      }
+    } finally {
+      cleanup();
+    }
+  });
+
+repoCmd
+  .command('list')
+  .description('List the org\'s registered repos with their .agents/ index counts')
+  .option('--org <org>', 'resolve against this Drafted org (id or name); scopes per-request without switching the session')
+  .option('--format <fmt>', 'output format: json or text', 'text')
+  .action(async (opts) => {
+    const data = await readApiGet('repo:list', '/api/repos', opts.org);
+    const rows = data.repos || [];
+    if (opts.format === 'json') { console.log(JSON.stringify(rows)); return; }
+    for (const r of rows) console.log([r.slug, r.gitUrl, r.defaultBranch, `skills:${r.skillCount ?? 0}`, `identities:${r.identityCount ?? 0}`, r.description || ''].join('\t'));
+  });
+
+repoCmd
+  .command('remove <slugOrId>')
+  .description('Remove a registered repo (cascades its index entries)')
+  .option('--org <org>', 'resolve against this Drafted org (id or name); scopes per-request without switching the session')
+  .option('--format <fmt>', 'output format: json or text', 'text')
+  .action(async (slugOrId, opts) => {
+    requireLogin();
+    const orgHeaders = opts.org ? { 'X-Drafted-Org': opts.org } : {};
+    const server = getServerUrl().replace(/\/$/, '');
+    // UUID? DELETE directly. Otherwise resolve slug -> id via the list.
+    const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(slugOrId);
+    let id = isUuid ? slugOrId : null;
+    if (!id) {
+      const lookup = await authFetch(`${server}/api/repos`, { headers: orgHeaders });
+      const lj = await lookup.json().catch(() => ({}));
+      if (!lookup.ok) { if (opts.format === 'json') console.log(JSON.stringify({ ok: false, command: 'repo:remove', error: lj.error || `HTTP ${lookup.status}` })); else console.log(['error', lj.error || `HTTP ${lookup.status}`].join('\t')); process.exit(1); }
+      const found = (lj.repos || []).find((r) => r.slug === slugOrId);
+      if (!found) { if (opts.format === 'json') console.log(JSON.stringify({ ok: false, command: 'repo:remove', error: `no repo with slug "${slugOrId}"` })); else console.log(['error', `no repo with slug "${slugOrId}"`].join('\t')); process.exit(1); }
+      id = found.id;
+    }
+    const res = await authFetch(`${server}/api/repos/${encodeURIComponent(id)}`, { method: 'DELETE', headers: orgHeaders });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) { if (opts.format === 'json') console.log(JSON.stringify({ ok: false, command: 'repo:remove', error: data.error || `HTTP ${res.status}` })); else console.log(['error', data.error || `HTTP ${res.status}`].join('\t')); process.exit(1); }
+    if (opts.format === 'json') console.log(JSON.stringify({ ok: true, command: 'repo:remove', data: { id } }));
+    else console.log(['removed', id].join('\t'));
+  });
+
 program.parse();

package/cli/repo-scan.mjs

@@ -0,0 +1,146 @@
+// Repo `.agents/` scanner (org substrate normalization, Move C).
+//
+// Pure filesystem scan — no network, no DB. The CLI runs this against a repo
+// checkout (cloned to a temp dir for a URL, or a local path directly) and POSTs
+// the catalog to /api/repos. Content stays in git; only metadata + pointers are
+// sent. Mirrors the Agent Skills open format: `.agents/skills/<name>/SKILL.md`
+// (name + description frontmatter) and `.agents/identities/<slug>/identity.yaml`
+// (slug + name). See docs/plans/org-substrate-normalization.md.
+
+import { readFileSync, readdirSync, existsSync, mkdtempSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { execSync } from 'child_process';
+import { parse as parseYaml } from 'yaml';
+
+// ── Frontmatter ────────────────────────────────────────────────────
+
+/** Parse a YAML frontmatter block (`---\n...\n---`) from text. null if absent/invalid. */
+export function parseFrontmatter(text) {
+  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!m) return null;
+  try {
+    const parsed = parseYaml(m[1]);
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+// ── Scan ────────────────────────────────────────────────────────────
+
+/**
+ * Scan <dir>/.agents/skills/<name>/SKILL.md and <dir>/.agents/identities/<slug>/
+ * identity.yaml. Returns { skills, identities } catalog entries (metadata +
+ * pointers only — no file content). A skill with no frontmatter still indexes
+ * (name falls back to the dir). Identities index {slug, name} from identity.yaml.
+ */
+export function scanRepoAgents(dir) {
+  const skills = [];
+  const identities = [];
+  const agentsDir = join(dir, '.agents');
+
+  const skillsDir = join(agentsDir, 'skills');
+  if (existsSync(skillsDir)) {
+    for (const name of readdirSafe(skillsDir)) {
+      const skillMd = join(skillsDir, name, 'SKILL.md');
+      if (!existsSync(skillMd)) continue;
+      const fm = parseFrontmatter(readFileSync(skillMd, 'utf8')) || {};
+      skills.push({
+        kind: 'skill',
+        name: String(fm.name || name),
+        slug: name,
+        description: fm.description != null ? String(fm.description) : '',
+        sourcePath: `.agents/skills/${name}`,
+      });
+    }
+  }
+
+  const identDir = join(agentsDir, 'identities');
+  if (existsSync(identDir)) {
+    for (const name of readdirSafe(identDir)) {
+      const idYaml = join(identDir, name, 'identity.yaml');
+      if (!existsSync(idYaml)) continue;
+      let fm = null;
+      try {
+        fm = parseYaml(readFileSync(idYaml, 'utf8')) || {};
+      } catch {
+        fm = {};
+      }
+      identities.push({
+        kind: 'identity',
+        name: String(fm.name || fm.slug || name),
+        slug: String(fm.slug || name),
+        description: null,
+        sourcePath: `.agents/identities/${name}`,
+      });
+    }
+  }
+
+  return { skills, identities };
+}
+
+function readdirSafe(dir) {
+  try {
+    return readdirSync(dir).filter((n) => !n.startsWith('.'));
+  } catch {
+    return [];
+  }
+}
+
+/** Best-effort default branch of a git checkout. 'main' if git is unavailable. */
+export function detectDefaultBranch(dir) {
+  try {
+    const out = execSync('git rev-parse --abbrev-ref HEAD', {
+      cwd: dir,
+      stdio: ['ignore', 'pipe', 'ignore'],
+      encoding: 'utf8',
+    });
+    const branch = out.trim();
+    return branch || 'main';
+  } catch {
+    return 'main';
+  }
+}
+
+/** Remote origin URL of a git checkout, or null. */
+export function detectRemoteUrl(dir) {
+  try {
+    const out = execSync('git config --get remote.origin.url', {
+      cwd: dir,
+      stdio: ['ignore', 'pipe', 'ignore'],
+      encoding: 'utf8',
+    });
+    const url = out.trim();
+    return url || null;
+  } catch {
+    return null;
+  }
+}
+
+/** True if the argument looks like a git URL (not a local path). */
+export function isGitUrl(s) {
+  return /^(https?:|git@|ssh:\/\/|git:\/\/)/.test(s);
+}
+
+/** Clone a git URL into a fresh temp dir, returning { dir, cleanup }. */
+export function cloneToTemp(url) {
+  const dir = mkdtempSync(join(tmpdir(), 'drafted-repo-'));
+  execSync(`git clone --depth 1 ${shquote(url)} ${shquote(dir)}`, {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    encoding: 'utf8',
+  });
+  return {
+    dir,
+    cleanup: () => {
+      try { execSync(`rm -rf ${shquote(dir)}`, { stdio: 'ignore' }); } catch { /* best effort */ }
+    },
+  };
+}
+
+// Minimal shell quoting — clone targets are user-supplied URLs. We only pass
+// them to git as a single argv via execSync through a shell string, so quote to
+// avoid metacharacter injection. (The URL is also validated by git itself.)
+function shquote(s) {
+  return `'${String(s).replace(/'/g, "'\\''")}'`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drafted",
-  "version": "1.17.3",
+  "version": "1.17.5",
   "description": "Drafted — visual thinking surface for humans and AI agents. Renders HTML, markdown, images, and code as frames on a zoomable canvas, with MCP tools for AI agents and real-time sync for humans.",
   "type": "module",
   "files": [
@@ -72,6 +72,7 @@
     "react-dom": "^18.3.1",
     "sharp": "^0.34.5",
     "ws": "^8.16.0",
+    "yaml": "^2.8.3",
     "zod": "^4.3.6"
   },
   "keywords": [
@@ -95,7 +96,6 @@
     "drizzle-kit": "^0.31.9",
     "tsx": "^4.19.0",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4",
-    "yaml": "^2.8.3"
+    "vitest": "^3.2.4"
   }
 }