@botdocs/cli 0.5.0 → 0.8.0

package/dist/commands/ingest.js

@@ -1,12 +1,189 @@
+import React from 'react';
 import fs from 'node:fs';
 import path from 'node:path';
+import { render } from 'ink';
 import { apiFetch } from '../lib/api.js';
+import { discoverSkills, ecosystemLabel, formatBytes, STUB_BYTE_THRESHOLD, summaryKey, titleFromContent, } from '../lib/ingest-discover.js';
+import { IngestDiscoverApp } from './views/ingest-discover-app.js';
+// ---------- Cap + skip rules (shared with discovery) ----------
+//
+// Caps are tight by design — Claude skills routinely fit well under these.
+// Enforced both here (CLI) and server-side (defense in depth).
+/** Per-file size cap. Any file larger than this is skipped with a warning. */
+export const PER_FILE_BYTE_CAP = 64 * 1024; // 64 KB
+/** Total bytes across all files in a single skill. */
+export const PER_SKILL_BYTE_CAP = 512 * 1024; // 512 KB
+/** Total file count in a single skill. */
+export const PER_SKILL_FILE_CAP = 25;
+/** Directories the sweep recurses INTO. Anything else is silently ignored.
+ * The set is duplicated (not imported) from `walkFiles` so it stays in sync
+ * with what the path-based walker already filters out. */
+const SWEEP_SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    '.next',
+    '.turbo',
+    '__pycache__',
+    'venv',
+    '.venv',
+]);
+/** Filenames + globs that are uninteresting noise. `.log` and `.lock` are
+ * matched via endsWith, not regex, to keep the check cheap. */
+function isSkippedFileName(name) {
+    if (name === '.DS_Store')
+        return true;
+    if (name.endsWith('.log'))
+        return true;
+    if (name.endsWith('.lock'))
+        return true;
+    return false;
+}
+/** Binary detection: read the first 8 KB and look for a null byte. Matches
+ * the same heuristic git uses. Cheap and good enough — we'd rather refuse a
+ * borderline file than try to base64 it. */
+function looksBinary(absPath) {
+    const buf = Buffer.alloc(8192);
+    let fd = null;
+    try {
+        fd = fs.openSync(absPath, 'r');
+        const bytesRead = fs.readSync(fd, buf, 0, 8192, 0);
+        for (let i = 0; i < bytesRead; i++) {
+            if (buf[i] === 0)
+                return true;
+        }
+        return false;
+    }
+    catch {
+        // Unreadable — treat as binary so we skip it with a warning rather than
+        // crashing the whole ingest.
+        return true;
+    }
+    finally {
+        if (fd !== null) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+}
+/**
+ * Walk a skill root recursively and return every non-skipped file the caller
+ * should ingest as an adjacent file. Applies dir-skip, dotfile, binary, and
+ * cap rules. Stops collecting once total caps are exceeded — remaining files
+ * land in `warnings`. The root file (e.g. SKILL.md) is excluded so the caller
+ * can handle it separately.
+ */
+export function sweepSkillRoot(skillRoot, rootFileAbs) {
+    const files = [];
+    const warnings = [];
+    let totalBytes = 0;
+    function walk(dir) {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const abs = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (SWEEP_SKIP_DIRS.has(entry.name))
+                    continue;
+                if (entry.name.startsWith('.'))
+                    continue;
+                walk(abs);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (abs === rootFileAbs)
+                continue;
+            if (entry.name.startsWith('.'))
+                continue;
+            if (isSkippedFileName(entry.name))
+                continue;
+            const relPath = path.relative(skillRoot, abs).split(path.sep).join('/');
+            let stat;
+            try {
+                stat = fs.statSync(abs);
+            }
+            catch {
+                warnings.push({ relPath, reason: 'binary' });
+                continue;
+            }
+            if (stat.size > PER_FILE_BYTE_CAP) {
+                warnings.push({ relPath, reason: 'oversize' });
+                continue;
+            }
+            if (looksBinary(abs)) {
+                warnings.push({ relPath, reason: 'binary' });
+                continue;
+            }
+            // Total-byte cap is checked after the per-file gate so a single huge
+            // file doesn't blow past the skill cap before we've read it.
+            if (totalBytes + stat.size > PER_SKILL_BYTE_CAP) {
+                warnings.push({ relPath, reason: 'cap-total-size' });
+                continue;
+            }
+            // -1 here because we count the root file in the caller's accounting,
+            // but exclude it from this sweep. Cap is "total files per skill".
+            if (files.length + 1 >= PER_SKILL_FILE_CAP) {
+                warnings.push({ relPath, reason: 'cap-file-count' });
+                continue;
+            }
+            let content;
+            try {
+                content = fs.readFileSync(abs, 'utf-8');
+            }
+            catch {
+                warnings.push({ relPath, reason: 'binary' });
+                continue;
+            }
+            files.push({
+                absPath: abs,
+                relPath,
+                content,
+                mode: stat.mode & 0o777,
+                sizeBytes: stat.size,
+            });
+            totalBytes += stat.size;
+        }
+    }
+    walk(skillRoot);
+    return { files, warnings };
+}
+/** Format a sweep warning summary line for a single skill. Empty string when
+ * there are no warnings — caller can use that to suppress the line. */
+export function formatSweepWarnings(slug, warnings) {
+    if (warnings.length === 0)
+        return '';
+    const binary = warnings.filter((w) => w.reason === 'binary').map((w) => w.relPath);
+    const oversize = warnings.filter((w) => w.reason === 'oversize').map((w) => w.relPath);
+    const totalCap = warnings.filter((w) => w.reason === 'cap-total-size').map((w) => w.relPath);
+    const fileCap = warnings.filter((w) => w.reason === 'cap-file-count').map((w) => w.relPath);
+    const parts = [];
+    if (binary.length)
+        parts.push(`${binary.length} binary (${binary.slice(0, 3).join(', ')}${binary.length > 3 ? '…' : ''})`);
+    if (oversize.length)
+        parts.push(`${oversize.length} over 64KB (${oversize.slice(0, 3).join(', ')}${oversize.length > 3 ? '…' : ''})`);
+    if (totalCap.length)
+        parts.push(`${totalCap.length} past 512KB total cap`);
+    if (fileCap.length)
+        parts.push(`${fileCap.length} past 25-file cap`);
+    return `  ⚠ ${slug}: skipped ${warnings.length} file(s) — ${parts.join('; ')}`;
+}
 /**
  * Single source of truth for ecosystem detection. New ecosystems should be
  * added here — both auto-detect mode and future `--from-tool` mode consult
  * this table.
  */
-const DETECTORS = {
+export const DETECTORS = {
     claude: {
         pathPrefix: 'claude/',
         extensions: ['/SKILL.md'],
@@ -22,6 +199,14 @@ const DETECTORS = {
             return parts[parts.length - 2] ?? null;
         },
         canonicalFilename: (slug) => `claude/${slug}/SKILL.md`,
+        // Discovery walks ~/.claude/skills recursively — files live one or two
+        // segments deep (`<slug>/SKILL.md` or `<scope>/<slug>/SKILL.md`).
+        scanPaths: (homeDir) => [path.join(homeDir, '.claude', 'skills')],
+        // Marquee case for adjacent-file sweep: real Claude skills bundle
+        // scripts/, templates/, and reference markdown next to SKILL.md.
+        includeAdjacent: true,
+        skillRoot: (abs) => path.dirname(abs),
+        canonicalAdjacentFilename: (slug, relPath) => `claude/${slug}/${relPath}`,
     },
     'claude-code': {
         pathPrefix: 'claude-code/commands/',
@@ -29,6 +214,52 @@ const DETECTORS = {
         nested: false,
         slugFor: (abs) => path.basename(abs).replace(/\.md$/, '') || null,
         canonicalFilename: (slug) => `claude-code/commands/${slug}.md`,
+        // Two locations: global ~/.claude/commands always, project .claude/commands
+        // only inside a git repo (per-repo overrides).
+        scanPaths: (homeDir, projectRoot, isGitRepo) => {
+            const paths = [path.join(homeDir, '.claude', 'commands')];
+            if (isGitRepo)
+                paths.push(path.join(projectRoot, '.claude', 'commands'));
+            return paths;
+        },
+        // Commands are FLAT today — every .md in ~/.claude/commands/ is its own
+        // skill, with no enclosing directory. That means there's no meaningful
+        // "skill root" to sweep: the dirname of a command is shared with all
+        // other commands, and walking it would produce false-positive adjacent
+        // files. If Anthropic ever adds a directory layout for commands we'll
+        // flip this back to `true` and add the appropriate skillRoot logic.
+        includeAdjacent: false,
+    },
+    'claude-code-agents': {
+        // Anthropic's convention today is single-file agents at
+        // `.claude/agents/<name>.md`. For BotDocs multi-file agents we expect a
+        // directory: `.claude/agents/<name>/AGENT.md` + adjacent files. The
+        // detector matches `**/AGENT.md` under `claude-code/agents/`; the slug
+        // is the parent dir of AGENT.md.
+        pathPrefix: 'claude-code/agents/',
+        extensions: ['/AGENT.md'],
+        nested: true,
+        slugFor: (abs, root) => {
+            const rel = path.relative(root, abs).split(path.sep).join('/');
+            if (!rel.endsWith('/AGENT.md'))
+                return null;
+            const parts = rel.split('/');
+            if (parts.length < 2)
+                return null;
+            return parts[parts.length - 2] ?? null;
+        },
+        canonicalFilename: (slug) => `claude-code/agents/${slug}/AGENT.md`,
+        // Mirror claude-code commands: global ~/.claude/agents always, project
+        // .claude/agents only inside a git repo.
+        scanPaths: (homeDir, projectRoot, isGitRepo) => {
+            const paths = [path.join(homeDir, '.claude', 'agents')];
+            if (isGitRepo)
+                paths.push(path.join(projectRoot, '.claude', 'agents'));
+            return paths;
+        },
+        includeAdjacent: true,
+        skillRoot: (abs) => path.dirname(abs),
+        canonicalAdjacentFilename: (slug, relPath) => `claude-code/agents/${slug}/${relPath}`,
     },
     cursor: {
         pathPrefix: 'cursor/rules/',
@@ -36,6 +267,7 @@ const DETECTORS = {
         nested: false,
         slugFor: (abs) => path.basename(abs).replace(/\.mdc$/, '') || null,
         canonicalFilename: (slug) => `cursor/rules/${slug}.mdc`,
+        scanPaths: (_homeDir, projectRoot, isGitRepo) => isGitRepo ? [path.join(projectRoot, '.cursor', 'rules')] : [],
     },
     chatgpt: {
         pathPrefix: 'chatgpt/',
@@ -43,6 +275,8 @@ const DETECTORS = {
         nested: false,
         slugFor: (abs) => path.basename(abs).replace(/\.md$/, '') || null,
         canonicalFilename: (slug) => `chatgpt/${slug}.md`,
+        // No canonical on-disk location — ChatGPT is a manual-paste ecosystem.
+        scanPaths: () => [],
     },
     codex: {
         pathPrefix: 'codex/',
@@ -50,6 +284,7 @@ const DETECTORS = {
         nested: false,
         slugFor: (abs) => path.basename(abs).replace(/\.md$/, '') || null,
         canonicalFilename: (slug) => `codex/${slug}.md`,
+        scanPaths: (_homeDir, projectRoot, isGitRepo) => isGitRepo ? [path.join(projectRoot, '.codex', 'skills')] : [],
     },
     copilot: {
         pathPrefix: 'copilot/instructions/',
@@ -58,6 +293,7 @@ const DETECTORS = {
         nested: false,
         slugFor: (abs) => path.basename(abs).replace(/\.instructions\.md$/, '') || null,
         canonicalFilename: (slug) => `copilot/instructions/${slug}.instructions.md`,
+        scanPaths: (_homeDir, projectRoot, isGitRepo) => isGitRepo ? [path.join(projectRoot, '.github', 'instructions')] : [],
     },
     windsurf: {
         pathPrefix: 'windsurf/rules/',
@@ -65,6 +301,7 @@ const DETECTORS = {
         nested: false,
         slugFor: (abs) => path.basename(abs).replace(/\.md$/, '') || null,
         canonicalFilename: (slug) => `windsurf/rules/${slug}.md`,
+        scanPaths: (_homeDir, projectRoot, isGitRepo) => isGitRepo ? [path.join(projectRoot, '.codeium', 'windsurf-rules')] : [],
     },
     gemini: {
         pathPrefix: 'gemini/instructions/',
@@ -72,6 +309,7 @@ const DETECTORS = {
         nested: false,
         slugFor: (abs) => path.basename(abs).replace(/\.md$/, '') || null,
         canonicalFilename: (slug) => `gemini/instructions/${slug}.md`,
+        scanPaths: (homeDir) => [path.join(homeDir, '.gemini', 'instructions')],
     },
     antigravity: {
         pathPrefix: 'antigravity/skills/',
@@ -79,6 +317,7 @@ const DETECTORS = {
         nested: false,
         slugFor: (abs) => path.basename(abs).replace(/\.md$/, '') || null,
         canonicalFilename: (slug) => `antigravity/skills/${slug}.md`,
+        scanPaths: (homeDir) => [path.join(homeDir, '.gemini', 'antigravity', 'skills')],
     },
     opencode: {
         pathPrefix: 'opencode/instructions/',
@@ -86,16 +325,16 @@ const DETECTORS = {
         nested: false,
         slugFor: (abs) => path.basename(abs).replace(/\.md$/, '') || null,
         canonicalFilename: (slug) => `opencode/instructions/${slug}.md`,
+        scanPaths: (homeDir) => [path.join(homeDir, '.config', 'opencode', 'instructions')],
     },
 };
 export const SUPPORTED_TOOLS = Object.keys(DETECTORS);
-const IGNORED_DIRS = new Set(['node_modules', '.git', '.next', 'dist', 'build', '.turbo']);
 function walkFiles(root) {
     const out = [];
     function walk(dir) {
         for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
             if (entry.isDirectory()) {
-                if (IGNORED_DIRS.has(entry.name) || entry.name.startsWith('.'))
+                if (SWEEP_SKIP_DIRS.has(entry.name) || entry.name.startsWith('.'))
                     continue;
                 walk(path.join(dir, entry.name));
             }
@@ -107,6 +346,16 @@ function walkFiles(root) {
     walk(root);
     return out;
 }
+/** Stat helper that masks mode to the low 9 bits (rwx for owner/group/other).
+ * Falls back to 0o644 on error so we never block ingest on a stat failure. */
+function safeMode(absPath) {
+    try {
+        return fs.statSync(absPath).mode & 0o777;
+    }
+    catch {
+        return 0o644;
+    }
+}
 /** Does the filename end with any of the detector's declared extensions? */
 function matchesExtension(absPath, detector) {
     return detector.extensions.some((ext) => absPath.endsWith(ext));
@@ -130,6 +379,7 @@ function detectAuto(absPath, root, content) {
             content,
             ecosystem,
             slug,
+            mode: safeMode(absPath),
         };
     }
     return null;
@@ -155,11 +405,243 @@ function detectFromTool(absPath, root, content, ecosystem) {
         content,
         ecosystem,
         slug,
+        mode: safeMode(absPath),
     };
 }
-function titleFromContent(content, slug) {
-    const m = content.match(/^#\s+(.+)$/m);
-    return m?.[1]?.trim() ?? slug.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
+/**
+ * Sweep adjacent files when a detector opts in. Returns a list of
+ * `DetectedFile` for each non-skipped sibling file, plus warnings the caller
+ * surfaces inline. The root file itself is excluded — caller already has it.
+ */
+function adjacentFilesFor(detector, ecosystem, slug, rootFileAbs) {
+    if (!detector.includeAdjacent || !detector.skillRoot || !detector.canonicalAdjacentFilename) {
+        return { files: [], warnings: [] };
+    }
+    const root = detector.skillRoot(rootFileAbs);
+    const result = sweepSkillRoot(root, rootFileAbs);
+    const files = result.files.map((f) => ({
+        filename: detector.canonicalAdjacentFilename(slug, f.relPath),
+        content: f.content,
+        ecosystem,
+        slug,
+        mode: f.mode,
+    }));
+    return { files, warnings: result.warnings };
+}
+/** Group a list of discovered files into the `DetectedSkill[]` shape the
+ * `/api/cli/ingest` endpoint expects. Multiple discoveries with the same slug
+ * collapse into one logical skill with multiple files — same convention as
+ * the path-based ingest path uses. */
+function groupDiscoveredIntoSkills(discovered) {
+    const grouped = new Map();
+    for (const f of discovered) {
+        if (!grouped.has(f.slug)) {
+            grouped.set(f.slug, {
+                slug: f.slug,
+                title: f.title,
+                description: '',
+                sourceEcosystem: f.ecosystem,
+                files: [],
+            });
+        }
+        grouped.get(f.slug).files.push({
+            filename: f.canonicalFilename,
+            content: f.content,
+            mode: f.mode,
+        });
+    }
+    return [...grouped.values()];
+}
+/** POST the grouped skills to the ingest endpoint. Honors `--json` (emit raw
+ * response) and the default human-friendly "drafts created" line. Returns
+ * nothing on success. */
+async function uploadSkills(skills, options) {
+    const result = await apiFetch('/api/cli/ingest', {
+        method: 'POST',
+        auth: true,
+        body: { skills, bundle: options.bundle ? { name: options.bundle } : undefined },
+    });
+    if (options.json) {
+        console.log(JSON.stringify(result));
+        return;
+    }
+    console.log(`\n  ✓ Drafts created. Review at:\n    https://botdocs.ai${result.reviewUrl}\n`);
+}
+/** Returns true if this file is the "root" for its skill — the file the user
+ * sees as a checkbox row in the TUI / a bullet in plain-text output. Adjacent
+ * files (scripts/, templates/, etc.) ride along with the root's selection. */
+function isRoot(file) {
+    const cf = file.canonicalFilename;
+    // Nested ecosystems use /SKILL.md or /AGENT.md as the root marker.
+    if (cf.endsWith('/SKILL.md') || cf.endsWith('/AGENT.md'))
+        return true;
+    // Flat ecosystems have no adjacent sweep today, so every file IS a root.
+    // Detect by checking that the canonical filename matches the simple
+    // `<prefix>/<slug>.<ext>` shape with no extra path segment.
+    // (A claude-code-agents single-file would also match here — but we only
+    // produce AGENT.md as the root for nested layouts, so flat .md under
+    // claude-code/agents/ is treated as a root.)
+    return !cf.includes('/scripts/') && !cf.includes('/templates/') && !cf.includes('/reference/');
+}
+/** Filter a discovery file list down to the set the `--auto` / stub filter
+ * would actually upload: only ROOT files smaller than the stub threshold are
+ * dropped. Adjacent files ride along when their root is eligible. */
+function applyStubFilter(files) {
+    const eligibleKeys = new Set();
+    for (const f of files) {
+        if (!isRoot(f))
+            continue;
+        if (f.sizeBytes >= STUB_BYTE_THRESHOLD)
+            eligibleKeys.add(summaryKey(f));
+    }
+    return files.filter((f) => eligibleKeys.has(summaryKey(f)));
+}
+/** Render a sectioned plain-text listing of discoveries. Reused for both
+ * `--dry-run` output and the non-TTY fallback. Adjacent files are not listed
+ * row-by-row — the per-skill aggregate `(SKILL.md + N)` is enough signal. */
+function printDiscoveryPlainText(discovered, skillSummaries) {
+    const rootFiles = discovered.filter(isRoot);
+    const byEcosystem = new Map();
+    for (const d of rootFiles) {
+        const list = byEcosystem.get(d.ecosystem) ?? [];
+        list.push(d);
+        byEcosystem.set(d.ecosystem, list);
+    }
+    console.log('');
+    console.log(`  Found ${rootFiles.length} skill(s) across ${byEcosystem.size} tool(s):`);
+    for (const [eco, list] of byEcosystem) {
+        console.log('');
+        console.log(`  ${ecosystemLabel(eco)}:`);
+        for (const f of list) {
+            const label = f.scope ? `${f.scope}/${f.slug}` : f.slug;
+            const stub = f.sizeBytes < STUB_BYTE_THRESHOLD ? ' (stub — excluded by default)' : '';
+            const summary = skillSummaries?.get(summaryKey(f));
+            const details = summary && summary.totalFiles > 1
+                ? `${formatBytes(summary.totalBytes)} · ${summary.totalFiles} files`
+                : `${formatBytes(f.sizeBytes)} · ${f.lineCount} lines`;
+            console.log(`    • ${label}   ${details}${stub}`);
+            // Render any sweep warnings as a sub-bullet under the skill — keeps
+            // the per-ecosystem section readable.
+            if (summary && summary.warnings.length > 0) {
+                const line = formatSweepWarnings(label, summary.warnings);
+                if (line)
+                    console.log(`    ${line.trimStart()}`);
+            }
+        }
+    }
+    console.log('');
+}
+/** The zero-argument discovery entry point. Scans known on-disk locations,
+ * routes through the TUI (or its fallbacks) per the user's options + tty
+ * state, and uploads the user's selection. */
+async function ingestDiscover(options) {
+    const discovery = discoverSkills();
+    if (discovery.files.length === 0) {
+        console.log('\n  No skills found. Try `botdocs init` to scaffold a new one, or point at a path: `botdocs ingest <dir>`\n');
+        return;
+    }
+    // --json: emit the discovery shape (no TUI, no upload) so CI / scripts can
+    // consume it. Includes per-file metadata; content is omitted to keep the
+    // payload small — callers can re-run with a path to actually upload.
+    if (options.json) {
+        // Only emit root files (one per skill). Adjacent files are aggregated
+        // into `totalFiles` / `totalBytes` so the JSON consumer sees the same
+        // shape the TUI shows.
+        const payload = discovery.files
+            .filter(isRoot)
+            .map((f) => {
+            const summary = discovery.skillSummaries.get(summaryKey(f));
+            return {
+                ecosystem: f.ecosystem,
+                slug: f.slug,
+                scope: f.scope,
+                title: f.title,
+                sourcePath: f.sourcePath,
+                sizeBytes: f.sizeBytes,
+                lineCount: f.lineCount,
+                canonicalFilename: f.canonicalFilename,
+                totalFiles: summary?.totalFiles ?? 1,
+                totalBytes: summary?.totalBytes ?? f.sizeBytes,
+            };
+        });
+        console.log(JSON.stringify({ discovered: payload, emptyEcosystems: discovery.emptyEcosystems }));
+        return;
+    }
+    // --dry-run + --auto: list the FILTERED set --auto would actually upload
+    // (stubs excluded). Helps the user verify before re-running without
+    // --dry-run.
+    if (options.dryRun && options.auto) {
+        const eligible = applyStubFilter(discovery.files);
+        printDiscoveryPlainText(eligible, discovery.skillSummaries);
+        console.log('  --dry-run --auto: would upload the above (stubs excluded). Not uploading.\n');
+        return;
+    }
+    // --dry-run alone: list ALL discoveries in plain text, never upload, never
+    // TUI. Stubs are marked inline so the user knows they'd be excluded.
+    if (options.dryRun) {
+        printDiscoveryPlainText(discovery.files, discovery.skillSummaries);
+        console.log('  --dry-run: not uploading.\n');
+        return;
+    }
+    // --auto: skip the TUI and upload everything matching the defaults (stubs
+    // < STUB_BYTE_THRESHOLD bytes excluded — same rule the TUI uses). The
+    // stub filter looks at the root file only; adjacent files always ride
+    // along when their root is selected.
+    if (options.auto) {
+        const eligible = applyStubFilter(discovery.files);
+        if (eligible.length === 0) {
+            console.log('\n  No skills found (all discovered files are < 100-byte stubs). Inspect with `--dry-run`.\n');
+            return;
+        }
+        const skills = groupDiscoveredIntoSkills(eligible);
+        console.log(`\n  ✓ Uploading ${skills.length} skill(s) found by discovery (--auto):`);
+        for (const s of skills)
+            console.log(`    • ${s.slug} (${s.files.length} file(s))`);
+        // Surface any sweep warnings inline so the user knows what got dropped.
+        for (const [, summary] of discovery.skillSummaries) {
+            if (summary.warnings.length === 0)
+                continue;
+            const label = summary.scope ? `${summary.scope}/${summary.slug}` : summary.slug;
+            const line = formatSweepWarnings(label, summary.warnings);
+            if (line)
+                console.log(line);
+        }
+        await uploadSkills(skills, options);
+        return;
+    }
+    const useInk = !options.noInk && Boolean(process.stdout.isTTY);
+    if (!useInk) {
+        // Non-TTY / piped / --no-ink: print plain text and exit. We deliberately
+        // do NOT upload silently here — interactive consent matters. The user
+        // can re-run with `--json` for machine-readable output or with `--auto`
+        // for one-shot mode.
+        printDiscoveryPlainText(discovery.files, discovery.skillSummaries);
+        console.log('  Run with --json for machine-readable output, or in a real terminal for interactive selection.\n');
+        return;
+    }
+    // TUI path. The component owns the keyboard handling; we just wait for it
+    // to call `onDone`, unmount, then upload (if confirmed). The result holder
+    // is typed via the discriminated-union directly so the post-await branch
+    // narrows correctly.
+    const resultHolder = {
+        value: { kind: 'cancelled' },
+    };
+    const instance = render(React.createElement(IngestDiscoverApp, {
+        files: discovery.files,
+        skillSummaries: discovery.skillSummaries,
+        emptyEcosystems: discovery.emptyEcosystems,
+        onDone: (r) => {
+            resultHolder.value = r;
+        },
+    }));
+    await instance.waitUntilExit();
+    const result = resultHolder.value;
+    if (result.kind === 'cancelled') {
+        console.log('\n  Ingest cancelled.\n');
+        return;
+    }
+    const skills = groupDiscoveredIntoSkills(result.selected);
+    await uploadSkills(skills, options);
 }
 /** Human-readable list of all canonical path prefixes for the empty-result message. */
 function ecosystemPrefixSummary() {
@@ -168,6 +650,13 @@ function ecosystemPrefixSummary() {
         .join(', ');
 }
 export async function ingest(rootPath, options) {
+    // Zero-arg dispatch: scan known on-disk locations and route through the
+    // TUI (or its fallbacks). The existing path-based code path below stays
+    // identical.
+    if (!rootPath) {
+        await ingestDiscover(options);
+        return;
+    }
     const root = path.resolve(rootPath);
     if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) {
         console.error(`\n  ✗ Not a directory: ${rootPath}\n`);
@@ -180,13 +669,24 @@ export async function ingest(rootPath, options) {
         return;
     }
     const detected = [];
+    const sweepWarnings = [];
     for (const filePath of walkFiles(root)) {
         const content = fs.readFileSync(filePath, 'utf-8');
         const d = options.fromTool
             ? detectFromTool(filePath, root, content, options.fromTool)
             : detectAuto(filePath, root, content);
-        if (d)
-            detected.push(d);
+        if (!d)
+            continue;
+        detected.push(d);
+        // Sweep adjacent files when the detector opts in (claude SKILL.md, the
+        // new claude-code-agents AGENT.md). The root file we already pushed —
+        // this catches scripts/, templates/, reference docs, etc.
+        const detector = DETECTORS[d.ecosystem];
+        const { files: adjacent, warnings } = adjacentFilesFor(detector, d.ecosystem, d.slug, filePath);
+        detected.push(...adjacent);
+        const warningLine = formatSweepWarnings(d.slug, warnings);
+        if (warningLine)
+            sweepWarnings.push(warningLine);
     }
     if (detected.length === 0) {
         if (options.fromTool) {
@@ -211,25 +711,18 @@ export async function ingest(rootPath, options) {
                 files: [],
             });
         }
-        grouped.get(f.slug).files.push({ filename: f.filename, content: f.content });
+        grouped.get(f.slug).files.push({ filename: f.filename, content: f.content, mode: f.mode });
     }
     const skills = [...grouped.values()];
     console.log(`\n  ✓ Found ${skills.length} skill(s):`);
     for (const s of skills) {
         console.log(`    • ${s.slug} (${s.files.length} file(s))`);
     }
+    for (const line of sweepWarnings)
+        console.log(line);
     if (options.dryRun) {
         console.log('\n  --dry-run: not uploading.\n');
         return;
     }
-    const result = await apiFetch('/api/cli/ingest', {
-        method: 'POST',
-        auth: true,
-        body: { skills, bundle: options.bundle ? { name: options.bundle } : undefined },
-    });
-    if (options.json) {
-        console.log(JSON.stringify(result));
-        return;
-    }
-    console.log(`\n  ✓ Drafts created. Review at:\n    https://botdocs.ai${result.reviewUrl}\n`);
+    await uploadSkills(skills, options);
 }

package/dist/commands/install.js

@@ -55,6 +55,17 @@ async function downloadAndWrite(file, dest, options, projectDir) {
     }
     ensureDir(dest);
     fs.writeFileSync(dest, content, 'utf-8');
+    // Restore the file mode the author shipped. Defaults to 0o644 when the
+    // manifest omits `mode` (older server, pre-mode-column row, etc.). We
+    // explicitly chmod even when the value is 0o644 so a previously-executable
+    // file at the dest gets re-normalized to non-executable on update.
+    try {
+        fs.chmodSync(dest, file.mode ?? 0o644);
+    }
+    catch {
+        // chmod can fail on Windows / network mounts. Don't fail the install
+        // over a permission cosmetic — the file still got written.
+    }
     return { src: file.filename, dest, fingerprint: fingerprintFile(dest) };
 }
 async function installSkill(ref, manifest, options, scope) {