drafted 1.24.5 → 1.24.6

package/cli/repo-scan.mjs

@@ -0,0 +1,240 @@
+// 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, relative, sep } 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, <dir>/.agents/identities/<slug>/
+ * identity.yaml and <dir>/.wiki/**.md. Returns { skills, identities, wiki }
+ * 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. A wiki page's slug is its `.wiki/`-relative
+ * path with `.md` stripped, which is exactly its Drafted wiki path.
+ */
+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')) || {};
+      // README gate (Phase 1): a skill with no README.md still imports (foreign
+      // skills in the open Agent Skills format may legitimately omit one), but
+      // is flagged warn so the gap is visible. Never dropped.
+      const hasReadme = existsSync(join(skillsDir, name, 'README.md'));
+      skills.push({
+        kind: 'skill',
+        name: String(fm.name || name),
+        slug: name,
+        description: fm.description != null ? String(fm.description) : '',
+        sourcePath: `.agents/skills/${name}`,
+        readmePath: hasReadme ? `.agents/skills/${name}/README.md` : null,
+        status: hasReadme ? 'ok' : 'warn',
+        statusReason: hasReadme ? null : 'no README',
+      });
+    }
+  }
+
+  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, wiki: scanRepoWiki(dir) };
+}
+
+/**
+ * Scan <dir>/.wiki/**.md. One entry per page; `index.md` is skipped at every
+ * level because Drafted SYNTHESIZES it on read (a reserved path, never a stored
+ * page) — indexing it would shadow the synthesis with a stale copy.
+ */
+export function scanRepoWiki(dir) {
+  const root = join(dir, '.wiki');
+  if (!existsSync(root)) return [];
+  const pages = [];
+  for (const file of walkMarkdown(root)) {
+    const rel = relative(root, file).split(sep).join('/');
+    if (rel.split('/').pop() === 'index.md') continue;
+    const text = readFileSync(file, 'utf8');
+    const fm = parseFrontmatter(text) || {};
+    const slug = rel.replace(/\.md$/, '');
+    pages.push({
+      kind: 'wiki',
+      name: String(fm.title || firstHeading(text) || slug.split('/').pop()),
+      slug,
+      description: fm.description != null ? String(fm.description) : '',
+      sourcePath: `.wiki/${rel}`,
+    });
+  }
+  return pages.sort((a, b) => a.slug.localeCompare(b.slug));
+}
+
+function firstHeading(text) {
+  const m = text.match(/^#\s+(.+)$/m);
+  return m ? m[1].trim() : null;
+}
+
+/** Recursively yield every `.md` file under dir, skipping dot-entries. */
+function* walkMarkdown(dir) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    if (e.name.startsWith('.')) continue;
+    const full = join(dir, e.name);
+    if (e.isDirectory()) yield* walkMarkdown(full);
+    else if (e.isFile() && e.name.endsWith('.md')) yield full;
+  }
+}
+
+function readdirSafe(dir) {
+  try {
+    return readdirSync(dir).filter((n) => !n.startsWith('.'));
+  } catch {
+    return [];
+  }
+}
+
+// ── Seed-on-link ────────────────────────────────────────────────────
+
+/**
+ * Classify what seeding a folder's wiki + skills onto a branch would do.
+ *
+ * Linking is a MIGRATION, not a flag flip: the folder's existing content must
+ * land in git BEFORE the folder flips to repo-owned, or every page and skill it
+ * already holds becomes unauthorable and shadowed. So a path already on the
+ * branch is a CONFLICT — refuse the link and list them — unless the content is
+ * identical, which makes it a no-op and keeps `link -> detach -> link` idempotent.
+ *
+ * @param {Map<string,string>|object} existing branch path -> file content
+ * @param {{path:string, content:string}[]} seed what the folder would write
+ * @returns {{creates:string[], identical:string[], conflicts:string[]}}
+ */
+export function classifySeed(existing, seed) {
+  const get = existing instanceof Map ? (p) => existing.get(p) : (p) => existing?.[p];
+  const out = { creates: [], identical: [], conflicts: [] };
+  for (const f of seed || []) {
+    const there = get(f.path);
+    if (there === undefined || there === null) out.creates.push(f.path);
+    else if (sameContent(there, f.content)) out.identical.push(f.path);
+    else out.conflicts.push(f.path);
+  }
+  return out;
+}
+
+// ponytail: byte equality modulo line endings and trailing blank space. Enough
+// to make a re-link a no-op; if a semantic (frontmatter-order) diff ever matters,
+// compare parsed OKF instead.
+function sameContent(a, b) {
+  const norm = (s) => String(s ?? '').replace(/\r\n/g, '\n').replace(/\s+$/, '');
+  return norm(a) === norm(b);
+}
+
+/** 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 }.
+ *  When `branch` is given, clone that branch only (--branch --single-branch) so a
+ *  missing branch fails loudly instead of silently landing on the default. */
+export function cloneToTemp(url, branch) {
+  const dir = mkdtempSync(join(tmpdir(), 'drafted-repo-'));
+  const branchArgs = branch ? `--branch ${shquote(branch)} --single-branch` : '';
+  execSync(`git clone --depth 1 ${branchArgs} ${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/cli/skill-setup-trust.mjs

@@ -0,0 +1,17 @@
+/**
+ * Whether `drafted skill sync` may run a skill's `setup:` (shell on this machine)
+ * without --allow-untrusted-setup.
+ *
+ * Only when YOU were the last to change the setup or any supporting file
+ * (`setupBy`, recorded by the server), the skill is not a fork (a fork carries
+ * another author's setup), and — if the ref pinned a hash — the bytes still match
+ * it. `createdBy` is not enough: any org member can edit another author's setup
+ * while createdBy stays the author (audit 2026-10-13). No setupBy (an older server,
+ * or an edit with no known editor) fails closed.
+ */
+export function setupTrusted(skill, { userId, pinnedHash } = {}) {
+  if (!userId || !skill?.setupBy || skill.setupBy !== userId) return false;
+  if (skill.forkedFrom) return false;
+  if (pinnedHash && !String(skill.hash || '').startsWith(pinnedHash)) return false;
+  return true;
+}