@crouton-kit/crouter 0.1.1 → 0.1.3

package/dist/core/fs-utils.js

@@ -0,0 +1,115 @@
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, symlinkSync, writeFileSync, cpSync, readlinkSync, } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { platform } from 'node:os';
+export function ensureDir(dir) {
+    mkdirSync(dir, { recursive: true });
+}
+export function writeJson(path, data) {
+    ensureDir(dirname(path));
+    writeFileSync(path, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+export function readJson(path) {
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+export function readJsonIfExists(path) {
+    if (!existsSync(path))
+        return null;
+    return readJson(path);
+}
+export function readTextIfExists(path) {
+    if (!existsSync(path))
+        return null;
+    return readFileSync(path, 'utf8');
+}
+export function readText(path) {
+    return readFileSync(path, 'utf8');
+}
+export function isDir(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export function isSymlink(path) {
+    try {
+        return lstatSync(path).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+export function pathExists(path) {
+    return existsSync(path);
+}
+export function listDirs(path) {
+    if (!existsSync(path))
+        return [];
+    return readdirSync(path, { withFileTypes: true })
+        .filter((d) => d.isDirectory() || d.isSymbolicLink())
+        .map((d) => d.name);
+}
+export function listEntries(path) {
+    if (!existsSync(path))
+        return [];
+    return readdirSync(path);
+}
+export function removePath(path) {
+    if (!existsSync(path) && !isSymlink(path))
+        return;
+    rmSync(path, { recursive: true, force: true });
+}
+export function linkOrCopy(target, linkPath, opts = {}) {
+    ensureDir(dirname(linkPath));
+    removePath(linkPath);
+    const isWindows = platform() === 'win32';
+    if (!opts.noSymlink && !isWindows) {
+        const rel = relative(dirname(linkPath), target);
+        try {
+            symlinkSync(rel, linkPath, isDir(target) ? 'dir' : 'file');
+            return 'symlink';
+        }
+        catch {
+            cpSync(target, linkPath, { recursive: true });
+            return 'copy';
+        }
+    }
+    cpSync(target, linkPath, { recursive: true });
+    return 'copy';
+}
+export function readSymlinkTarget(path) {
+    try {
+        return readlinkSync(path);
+    }
+    catch {
+        return null;
+    }
+}
+export function walkFiles(root, predicate = () => true) {
+    const out = [];
+    if (!existsSync(root))
+        return out;
+    const stack = [root];
+    while (stack.length) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            const full = join(dir, e.name);
+            if (e.isDirectory())
+                stack.push(full);
+            else if (e.isFile() && predicate(e.name))
+                out.push(full);
+        }
+    }
+    return out;
+}
+export function nowIso() {
+    return new Date().toISOString();
+}

package/dist/core/git.d.ts

@@ -0,0 +1,18 @@
+export interface GitResult {
+    status: number;
+    stdout: string;
+    stderr: string;
+}
+export declare function gitSync(args: string[], cwd?: string): GitResult;
+export declare function gitAsync(args: string[], cwd?: string): Promise<GitResult>;
+export declare function clone(url: string, dest: string, opts?: {
+    ref?: string;
+    depth?: number;
+}): GitResult;
+export declare function pull(cwd: string): GitResult;
+export declare function fetch(cwd: string, ref?: string): GitResult;
+export declare function lsRemote(url: string): GitResult;
+export declare function currentSha(cwd: string): string | null;
+export declare function remoteSha(cwd: string, ref: string): string | null;
+export declare function isGitRepo(cwd: string): boolean;
+export declare function deriveNameFromUrl(url: string): string;

package/dist/core/git.js

@@ -0,0 +1,71 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { network } from './errors.js';
+export function gitSync(args, cwd) {
+    const res = spawnSync('git', args, { cwd, encoding: 'utf8' });
+    const status = typeof res.status === 'number' ? res.status : 1;
+    const stdout = typeof res.stdout === 'string' ? res.stdout : '';
+    const stderr = typeof res.stderr === 'string' ? res.stderr : '';
+    return { status, stdout, stderr };
+}
+export async function gitAsync(args, cwd) {
+    return new Promise((resolve) => {
+        const child = spawn('git', args, { cwd });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (d) => (stdout += d.toString()));
+        child.stderr.on('data', (d) => (stderr += d.toString()));
+        child.on('close', (status) => {
+            const code = typeof status === 'number' ? status : 1;
+            resolve({ status: code, stdout, stderr });
+        });
+        child.on('error', (e) => resolve({ status: 1, stdout: '', stderr: String(e) }));
+    });
+}
+export function clone(url, dest, opts = {}) {
+    const args = ['clone'];
+    if (opts.depth)
+        args.push('--depth', String(opts.depth));
+    if (opts.ref)
+        args.push('--branch', opts.ref);
+    args.push(url, dest);
+    const res = gitSync(args);
+    if (res.status !== 0) {
+        throw network(`git clone failed: ${url}\n${res.stderr.trim()}`);
+    }
+    return res;
+}
+export function pull(cwd) {
+    return gitSync(['pull', '--ff-only'], cwd);
+}
+export function fetch(cwd, ref) {
+    const args = ['fetch', 'origin'];
+    if (ref)
+        args.push(ref);
+    return gitSync(args, cwd);
+}
+export function lsRemote(url) {
+    return gitSync(['ls-remote', url]);
+}
+export function currentSha(cwd) {
+    const res = gitSync(['rev-parse', 'HEAD'], cwd);
+    if (res.status !== 0)
+        return null;
+    return res.stdout.trim();
+}
+export function remoteSha(cwd, ref) {
+    const res = gitSync(['rev-parse', `origin/${ref}`], cwd);
+    if (res.status !== 0)
+        return null;
+    return res.stdout.trim();
+}
+export function isGitRepo(cwd) {
+    const res = gitSync(['rev-parse', '--is-inside-work-tree'], cwd);
+    return res.status === 0 && res.stdout.trim() === 'true';
+}
+export function deriveNameFromUrl(url) {
+    const trimmed = url.replace(/\.git\/?$/, '').replace(/\/$/, '');
+    const last = trimmed.split('/').pop();
+    if (!last)
+        return url;
+    return last;
+}

package/dist/core/manifest.d.ts

@@ -0,0 +1,5 @@
+import type { MarketplaceManifest, PluginManifest } from '../types.js';
+export declare function pluginManifestPath(pluginRoot: string): string;
+export declare function marketplaceManifestPath(mktRoot: string): string;
+export declare function readPluginManifest(pluginRoot: string): PluginManifest | null;
+export declare function readMarketplaceManifest(mktRoot: string): MarketplaceManifest | null;

package/dist/core/manifest.js

@@ -0,0 +1,15 @@
+import { join } from 'node:path';
+import { MARKETPLACE_MANIFEST_DIR, MARKETPLACE_MANIFEST_FILE, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE, } from '../types.js';
+import { readJsonIfExists } from './fs-utils.js';
+export function pluginManifestPath(pluginRoot) {
+    return join(pluginRoot, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
+}
+export function marketplaceManifestPath(mktRoot) {
+    return join(mktRoot, MARKETPLACE_MANIFEST_DIR, MARKETPLACE_MANIFEST_FILE);
+}
+export function readPluginManifest(pluginRoot) {
+    return readJsonIfExists(pluginManifestPath(pluginRoot));
+}
+export function readMarketplaceManifest(mktRoot) {
+    return readJsonIfExists(marketplaceManifestPath(mktRoot));
+}

package/dist/core/output.d.ts

@@ -0,0 +1,35 @@
+import { CrtrError } from './errors.js';
+export declare const stdoutColor: {
+    dim: (s: string) => string;
+    bold: (s: string) => string;
+    red: (s: string) => string;
+    green: (s: string) => string;
+    yellow: (s: string) => string;
+    blue: (s: string) => string;
+    cyan: (s: string) => string;
+    gray: (s: string) => string;
+};
+export declare const stderrColor: {
+    dim: (s: string) => string;
+    bold: (s: string) => string;
+    red: (s: string) => string;
+    green: (s: string) => string;
+    yellow: (s: string) => string;
+    blue: (s: string) => string;
+    cyan: (s: string) => string;
+    gray: (s: string) => string;
+};
+export declare function out(line: string): void;
+export declare function err(line: string): void;
+export declare function hint(line: string): void;
+export declare function warn(line: string): void;
+export declare function info(line: string): void;
+export declare function jsonOut(obj: unknown): void;
+export declare function jsonError(error: CrtrError | Error): void;
+export declare function isTTY(): boolean;
+export declare function isJsonRequested(opts: {
+    json?: boolean;
+} | undefined): boolean;
+export declare function handleError(error: unknown, opts?: {
+    json?: boolean;
+}): never;

package/dist/core/output.js

@@ -0,0 +1,99 @@
+import { CrtrError } from './errors.js';
+import { ExitCode, SCHEMA_VERSION } from '../types.js';
+const ANSI = {
+    reset: '\x1b[0m',
+    dim: '\x1b[2m',
+    bold: '\x1b[1m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+};
+function shouldColor(stream) {
+    if (process.env.NO_COLOR)
+        return false;
+    if (process.env.FORCE_COLOR)
+        return true;
+    return Boolean(stream.isTTY);
+}
+function paint(stream, code, text) {
+    return shouldColor(stream) ? `${code}${text}${ANSI.reset}` : text;
+}
+export const stdoutColor = {
+    dim: (s) => paint(process.stdout, ANSI.dim, s),
+    bold: (s) => paint(process.stdout, ANSI.bold, s),
+    red: (s) => paint(process.stdout, ANSI.red, s),
+    green: (s) => paint(process.stdout, ANSI.green, s),
+    yellow: (s) => paint(process.stdout, ANSI.yellow, s),
+    blue: (s) => paint(process.stdout, ANSI.blue, s),
+    cyan: (s) => paint(process.stdout, ANSI.cyan, s),
+    gray: (s) => paint(process.stdout, ANSI.gray, s),
+};
+export const stderrColor = {
+    dim: (s) => paint(process.stderr, ANSI.dim, s),
+    bold: (s) => paint(process.stderr, ANSI.bold, s),
+    red: (s) => paint(process.stderr, ANSI.red, s),
+    green: (s) => paint(process.stderr, ANSI.green, s),
+    yellow: (s) => paint(process.stderr, ANSI.yellow, s),
+    blue: (s) => paint(process.stderr, ANSI.blue, s),
+    cyan: (s) => paint(process.stderr, ANSI.cyan, s),
+    gray: (s) => paint(process.stderr, ANSI.gray, s),
+};
+export function out(line) {
+    process.stdout.write(line.endsWith('\n') ? line : line + '\n');
+}
+export function err(line) {
+    process.stderr.write(line.endsWith('\n') ? line : line + '\n');
+}
+export function hint(line) {
+    err(stderrColor.dim(`# ${line}`));
+}
+export function warn(line) {
+    err(stderrColor.yellow(`crtr: ${line}`));
+}
+export function info(line) {
+    err(stderrColor.gray(`crtr: ${line}`));
+}
+export function jsonOut(obj) {
+    const enriched = typeof obj === 'object' && obj !== null && !Array.isArray(obj)
+        ? { schema_version: SCHEMA_VERSION, ...obj }
+        : { schema_version: SCHEMA_VERSION, data: obj };
+    process.stdout.write(JSON.stringify(enriched, null, 2) + '\n');
+}
+export function jsonError(error) {
+    const e = error instanceof CrtrError ? error : new CrtrError('error', error.message, ExitCode.GENERAL);
+    process.stdout.write(JSON.stringify({
+        schema_version: SCHEMA_VERSION,
+        error: true,
+        code: e.code,
+        message: e.message,
+        ...(e.details ?? {}),
+    }, null, 2) + '\n');
+}
+export function isTTY() {
+    return Boolean(process.stdout.isTTY);
+}
+export function isJsonRequested(opts) {
+    return Boolean(opts?.json);
+}
+export function handleError(error, opts = {}) {
+    if (error instanceof CrtrError) {
+        if (opts.json) {
+            jsonError(error);
+        }
+        else {
+            err(stderrColor.red(`crtr: ${error.message}`));
+        }
+        process.exit(error.exitCode);
+    }
+    const e = error;
+    if (opts.json) {
+        jsonError(e);
+    }
+    else {
+        err(stderrColor.red(`crtr: ${e.message ?? String(e)}`));
+    }
+    process.exit(ExitCode.GENERAL);
+}

package/dist/core/resolver.d.ts

@@ -0,0 +1,28 @@
+import type { InstalledMarketplace, InstalledPlugin, Scope, ScopeConfig, Skill } from '../types.js';
+export declare function listInstalledPlugins(scope: Scope): InstalledPlugin[];
+export declare function listAllPlugins(): InstalledPlugin[];
+export declare function findPluginByName(name: string, scope?: Scope): InstalledPlugin | null;
+interface ScopeConfigs {
+    project?: ScopeConfig;
+    user: ScopeConfig;
+}
+export declare function effectiveSkillEnabled(pluginName: string, skillName: string, cfgs: ScopeConfigs): {
+    enabled: boolean;
+    disabledIn?: Scope;
+};
+export declare function listSkillsInPlugin(plugin: InstalledPlugin, cfgs?: ScopeConfigs): Skill[];
+export declare function listAllSkills(scopeFilter?: Scope): Skill[];
+export interface SkillResolutionOpts {
+    scope?: Scope;
+    pluginFilter?: string;
+}
+export declare function resolveSkill(rawName: string, opts?: SkillResolutionOpts): Skill;
+export declare function parseSkillQualifier(raw: string): {
+    plugin?: string;
+    name: string;
+};
+export declare function listInstalledMarketplaces(scope: Scope): InstalledMarketplace[];
+export declare function listAllMarketplaces(): InstalledMarketplace[];
+export declare function findMarketplaceByName(name: string, scope?: Scope): InstalledMarketplace | null;
+export declare function scopeRootsLabel(): string;
+export {};

package/dist/core/resolver.js

@@ -0,0 +1,228 @@
+import { join, relative, sep, dirname } from 'node:path';
+import { SKILL_ENTRY_FILE, SKILLS_DIR, skillConfigKey, } from '../types.js';
+import { readConfig } from './config.js';
+import { listDirs, pathExists, readText, walkFiles, } from './fs-utils.js';
+import { readMarketplaceManifest, readPluginManifest } from './manifest.js';
+import { parseFrontmatter } from './frontmatter.js';
+import { ambiguous, notFound } from './errors.js';
+import { marketplacesDir, pluginsDir, projectScopeRoot, userScopeRoot } from './scope.js';
+export function listInstalledPlugins(scope) {
+    const dir = pluginsDir(scope);
+    if (!dir || !pathExists(dir))
+        return [];
+    const cfg = readConfig(scope);
+    const out = [];
+    for (const name of listDirs(dir)) {
+        const root = join(dir, name);
+        const manifest = readPluginManifest(root);
+        if (!manifest)
+            continue;
+        const entry = cfg.plugins[name];
+        let version;
+        if (entry && entry.version !== undefined)
+            version = entry.version;
+        else if (manifest.version !== undefined)
+            version = manifest.version;
+        out.push({
+            name,
+            scope,
+            root,
+            manifest,
+            enabled: entry ? entry.enabled : true,
+            sourceMarketplace: entry ? entry.source_marketplace : undefined,
+            version,
+        });
+    }
+    return out;
+}
+export function listAllPlugins() {
+    const scopes = [];
+    if (projectScopeRoot())
+        scopes.push('project');
+    scopes.push('user');
+    return scopes.flatMap(listInstalledPlugins);
+}
+export function findPluginByName(name, scope) {
+    if (scope) {
+        return listInstalledPlugins(scope).find((p) => p.name === name) ?? null;
+    }
+    for (const s of ['project', 'user'].filter((sc) => sc === 'project' ? projectScopeRoot() !== null : true)) {
+        const match = listInstalledPlugins(s).find((p) => p.name === name);
+        if (match)
+            return match;
+    }
+    return null;
+}
+function loadScopeConfigs() {
+    const user = readConfig('user');
+    if (projectScopeRoot())
+        return { project: readConfig('project'), user };
+    return { user };
+}
+export function effectiveSkillEnabled(pluginName, skillName, cfgs) {
+    const key = skillConfigKey(pluginName, skillName);
+    if (cfgs.project && cfgs.project.skills[key] !== undefined) {
+        const e = cfgs.project.skills[key].enabled;
+        return e ? { enabled: true } : { enabled: false, disabledIn: 'project' };
+    }
+    if (cfgs.user.skills[key] !== undefined) {
+        const e = cfgs.user.skills[key].enabled;
+        return e ? { enabled: true } : { enabled: false, disabledIn: 'user' };
+    }
+    return { enabled: true };
+}
+export function listSkillsInPlugin(plugin, cfgs) {
+    const skillsRoot = join(plugin.root, SKILLS_DIR);
+    if (!pathExists(skillsRoot))
+        return [];
+    const configs = cfgs === undefined ? loadScopeConfigs() : cfgs;
+    const skills = [];
+    const skillFiles = walkFiles(skillsRoot, (n) => n === SKILL_ENTRY_FILE);
+    for (const file of skillFiles) {
+        const rel = relative(skillsRoot, dirname(file));
+        const name = rel.split(sep).join('/');
+        if (!name)
+            continue;
+        const source = readText(file);
+        const { data } = parseFrontmatter(source);
+        const { enabled, disabledIn } = effectiveSkillEnabled(plugin.name, name, configs);
+        skills.push({
+            name,
+            plugin: plugin.name,
+            scope: plugin.scope,
+            path: file,
+            pluginRoot: plugin.root,
+            frontmatter: data === null ? { name } : data,
+            enabled,
+            disabledIn,
+        });
+    }
+    return skills.sort((a, b) => a.name.localeCompare(b.name));
+}
+export function listAllSkills(scopeFilter) {
+    const plugins = scopeFilter ? listInstalledPlugins(scopeFilter) : listAllPlugins();
+    const cfgs = loadScopeConfigs();
+    return plugins
+        .filter((p) => p.enabled)
+        .flatMap((p) => listSkillsInPlugin(p, cfgs));
+}
+export function resolveSkill(rawName, opts = {}) {
+    const { plugin: pluginQualifier, name } = parseSkillQualifier(rawName);
+    const plugins = opts.scope ? listInstalledPlugins(opts.scope) : listAllPlugins();
+    const enabledPlugins = plugins.filter((p) => p.enabled);
+    const cfgs = loadScopeConfigs();
+    const ordered = orderPluginsByResolution(enabledPlugins);
+    const matches = [];
+    for (const plugin of ordered) {
+        if (pluginQualifier && plugin.name !== pluginQualifier)
+            continue;
+        if (opts.pluginFilter && plugin.name !== opts.pluginFilter)
+            continue;
+        const skillPath = join(plugin.root, SKILLS_DIR, ...name.split('/'), SKILL_ENTRY_FILE);
+        if (!pathExists(skillPath))
+            continue;
+        const source = readText(skillPath);
+        const { data } = parseFrontmatter(source);
+        const { enabled, disabledIn } = effectiveSkillEnabled(plugin.name, name, cfgs);
+        matches.push({
+            name,
+            plugin: plugin.name,
+            scope: plugin.scope,
+            path: skillPath,
+            pluginRoot: plugin.root,
+            frontmatter: data === null ? { name } : data,
+            enabled,
+            disabledIn,
+        });
+    }
+    if (matches.length === 0) {
+        throw notFound(pluginQualifier
+            ? `skill not found: ${pluginQualifier}:${name}`
+            : `skill not found: ${name}`, { skill: name, plugin: pluginQualifier });
+    }
+    if (matches.length === 1)
+        return matches[0];
+    const sameScopeAndPlugin = matches.every((m) => m.plugin === matches[0].plugin && m.scope === matches[0].scope);
+    if (sameScopeAndPlugin)
+        return matches[0];
+    // Resolution order picks the first; flag ambiguity only if user didn't qualify.
+    if (!pluginQualifier) {
+        return matches[0];
+    }
+    throw ambiguous(`ambiguous skill: ${name}`, {
+        skill: name,
+        candidates: matches.map((m) => ({
+            plugin: m.plugin,
+            scope: m.scope,
+            path: m.path,
+        })),
+    });
+}
+export function parseSkillQualifier(raw) {
+    const idx = raw.indexOf(':');
+    if (idx === -1)
+        return { name: raw };
+    return { plugin: raw.slice(0, idx), name: raw.slice(idx + 1) };
+}
+function orderPluginsByResolution(plugins) {
+    const score = (p) => {
+        const fromMarketplace = Boolean(p.sourceMarketplace);
+        if (p.scope === 'project' && !fromMarketplace)
+            return 0;
+        if (p.scope === 'user' && !fromMarketplace)
+            return 1;
+        if (p.scope === 'project' && fromMarketplace)
+            return 2;
+        return 3;
+    };
+    return [...plugins].sort((a, b) => score(a) - score(b));
+}
+export function listInstalledMarketplaces(scope) {
+    const dir = marketplacesDir(scope);
+    if (!dir || !pathExists(dir))
+        return [];
+    const cfg = readConfig(scope);
+    const out = [];
+    for (const name of listDirs(dir)) {
+        const root = join(dir, name);
+        const manifest = readMarketplaceManifest(root);
+        if (!manifest)
+            continue;
+        const entry = cfg.marketplaces[name];
+        const url = entry && entry.url !== undefined ? entry.url : '';
+        const ref = entry && entry.ref !== undefined ? entry.ref : 'main';
+        out.push({
+            name,
+            scope,
+            root,
+            manifest,
+            url,
+            ref,
+        });
+    }
+    return out;
+}
+export function listAllMarketplaces() {
+    const scopes = [];
+    if (projectScopeRoot())
+        scopes.push('project');
+    scopes.push('user');
+    return scopes.flatMap(listInstalledMarketplaces);
+}
+export function findMarketplaceByName(name, scope) {
+    if (scope) {
+        return listInstalledMarketplaces(scope).find((m) => m.name === name) ?? null;
+    }
+    for (const s of ['project', 'user']) {
+        if (s === 'project' && !projectScopeRoot())
+            continue;
+        const found = listInstalledMarketplaces(s).find((m) => m.name === name);
+        if (found)
+            return found;
+    }
+    return null;
+}
+export function scopeRootsLabel() {
+    const proj = projectScopeRoot();
+    return proj ? `project=${proj}, user=${userScopeRoot()}` : `user=${userScopeRoot()}`;
+}

package/dist/core/scope.d.ts

@@ -0,0 +1,12 @@
+import type { Scope } from '../types.js';
+export declare function userScopeRoot(): string;
+export declare function findProjectScopeRoot(startDir?: string): string | null;
+export declare function projectScopeRoot(startDir?: string): string | null;
+export declare function scopeRoot(scope: Scope): string | null;
+export declare function requireScopeRoot(scope: Scope): string;
+export declare function ensureProjectScopeRoot(startDir?: string): string;
+export declare function pluginsDir(scope: Scope): string | null;
+export declare function marketplacesDir(scope: Scope): string | null;
+export declare function resolveScopeArg(scopeArg: string | undefined): Scope | 'all';
+export declare function listScopes(scopeArg: string | undefined): Scope[];
+export declare function resetScopeCache(): void;