@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.18

package/dist/src/issues/sync.js

@@ -0,0 +1,143 @@
+export function attachExternalIssueSource(issue, source) {
+    return {
+        ...issue,
+        fields: {
+            ...issue.fields,
+            source: {
+                provider: source.provider,
+                external_id: source.external_id,
+                external_url: source.external_url ?? null,
+            },
+            links: {
+                ...issue.fields.links,
+                external: source.external_url ? uniqueStrings([...issue.fields.links.external, source.external_url]) : issue.fields.links.external,
+            },
+        },
+    };
+}
+export function buildLocalIssueConflictReport(localIssue, externalIssue) {
+    const conflicts = [];
+    compareField(conflicts, 'title', localIssue.fields.title, externalIssue.title, localIssue.fields.updated_at, externalIssue.updated_at);
+    compareField(conflicts, 'body', localIssue.body, externalIssue.body, localIssue.fields.updated_at, externalIssue.updated_at);
+    compareField(conflicts, 'status', localIssue.fields.status, normalizeExternalStatus(externalIssue.status), localIssue.fields.updated_at, externalIssue.updated_at);
+    compareField(conflicts, 'labels', [...localIssue.fields.labels].sort(), [...externalIssue.labels].sort(), localIssue.fields.updated_at, externalIssue.updated_at);
+    const commentConflicts = buildCommentConflictReport(localIssue.events ?? [], externalIssue.comments ?? [], localIssue.fields.updated_at, externalIssue.updated_at);
+    conflicts.push(...commentConflicts);
+    return {
+        issue_id: localIssue.fields.id,
+        provider: externalIssue.provider,
+        external_id: externalIssue.external_id,
+        external_url: externalIssue.external_url ?? null,
+        conflicts,
+    };
+}
+export function buildExternalIssueSnapshotFromLocal(localIssue, provider) {
+    const comments = (localIssue.events ?? [])
+        .filter((event) => (event.type === 'comment' || event.type === 'cycle_status') && event.body)
+        .map((event) => ({
+        local_event_id: event.event_id,
+        external_id: externalCommentId(event),
+        author: event.author,
+        body: event.body ?? '',
+        created_at: event.created_at,
+        updated_at: typeof event.data?.external_updated_at === 'string' ? event.data.external_updated_at : event.created_at,
+    }));
+    return {
+        provider,
+        local_issue_id: localIssue.fields.id,
+        external_id: localIssue.fields.source.provider === provider && localIssue.fields.source.external_id ? localIssue.fields.source.external_id : '',
+        external_url: localIssue.fields.source.provider === provider ? localIssue.fields.source.external_url ?? null : null,
+        title: localIssue.fields.title,
+        body: localIssue.body,
+        status: localIssue.fields.status === 'closed' ? 'closed' : 'open',
+        labels: [...localIssue.fields.labels],
+        created_at: localIssue.fields.created_at,
+        updated_at: localIssue.fields.updated_at,
+        comments,
+    };
+}
+export function parseExternalIssueSnapshot(value) {
+    if (!value || typeof value !== 'object')
+        throw new Error('external issue snapshot must be an object');
+    const candidate = value;
+    if (candidate.provider !== 'gitea' && candidate.provider !== 'github')
+        throw new Error('snapshot provider must be gitea or github');
+    const externalId = requireString(candidate.external_id, 'external_id');
+    const title = requireString(candidate.title, 'title');
+    const body = requireString(candidate.body, 'body');
+    const status = requireString(candidate.status, 'status');
+    const updatedAt = requireString(candidate.updated_at, 'updated_at');
+    if (!Array.isArray(candidate.labels) || !candidate.labels.every((label) => typeof label === 'string')) {
+        throw new Error('snapshot labels must be a string array');
+    }
+    if (candidate.comments !== undefined && (!Array.isArray(candidate.comments) || !candidate.comments.every(isExternalComment))) {
+        throw new Error('snapshot comments must be an array of comment snapshots');
+    }
+    return {
+        provider: candidate.provider,
+        external_id: externalId,
+        external_url: candidate.external_url ?? null,
+        title,
+        body,
+        status,
+        labels: candidate.labels,
+        created_at: candidate.created_at,
+        updated_at: updatedAt,
+        comments: candidate.comments ?? [],
+    };
+}
+export function parseCommentIdMappings(value) {
+    if (!Array.isArray(value))
+        throw new Error('comment mapping file must contain an array');
+    return value.map((item, index) => {
+        if (!item || typeof item !== 'object')
+            throw new Error(`comment mapping at index ${index} must be an object`);
+        const mapping = item;
+        return {
+            local_event_id: requireString(mapping.local_event_id, `comment mapping ${index}.local_event_id`),
+            external_comment_id: requireString(mapping.external_comment_id, `comment mapping ${index}.external_comment_id`),
+        };
+    });
+}
+function buildCommentConflictReport(localEvents, externalComments, localUpdatedAt, externalUpdatedAt) {
+    const conflicts = [];
+    const localByExternalId = new Map(localEvents
+        .map((event) => [externalCommentId(event), event])
+        .filter(([externalId]) => externalId));
+    for (const externalComment of externalComments) {
+        if (!externalComment.external_id)
+            continue;
+        const local = localByExternalId.get(externalComment.external_id);
+        if (!local)
+            continue;
+        compareField(conflicts, `comment:${externalComment.external_id}:body`, local.body ?? '', externalComment.body, typeof local.data?.external_updated_at === 'string' ? local.data.external_updated_at : localUpdatedAt, externalComment.updated_at ?? externalUpdatedAt);
+    }
+    return conflicts;
+}
+function compareField(conflicts, field, local, external, localUpdatedAt, externalUpdatedAt) {
+    if (JSON.stringify(local) === JSON.stringify(external))
+        return;
+    conflicts.push({ field, local, external, localUpdatedAt, externalUpdatedAt });
+}
+function normalizeExternalStatus(status) {
+    return status === 'closed' ? 'closed' : 'open';
+}
+function externalCommentId(event) {
+    const value = event.data?.external_comment_id;
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+function requireString(value, field) {
+    if (typeof value !== 'string')
+        throw new Error(`snapshot ${field} must be a string`);
+    return value;
+}
+function isExternalComment(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const comment = value;
+    return typeof comment.author === 'string' && typeof comment.body === 'string' && typeof comment.created_at === 'string';
+}
+function uniqueStrings(values) {
+    return [...new Set(values)];
+}
+//# sourceMappingURL=sync.js.map

package/dist/src/issues/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/issues/workflows.js

@@ -0,0 +1,164 @@
+import { LocalIssueProviderCore, localIssueRoot } from './index.js';
+export const QUESTION_LABEL = 'question';
+function hasLabel(labels, name) {
+    return labels.some((label) => label.toLowerCase() === name.toLowerCase());
+}
+/**
+ * Plan the tracker label mutation for address-issues open questions (#1726).
+ *
+ * The caller owns provider-specific API calls; this function keeps the state
+ * transition deterministic and idempotent across Gitea/GitHub/local stores.
+ */
+export function planQuestionLabelUpdate(input) {
+    const issueHasQuestion = hasLabel(input.issueLabels, QUESTION_LABEL);
+    const repoHasQuestion = hasLabel(input.repositoryLabels, QUESTION_LABEL);
+    const hasOpenQuestions = input.unresolvedQuestionCount > 0;
+    if (hasOpenQuestions) {
+        return {
+            label: QUESTION_LABEL,
+            createLabel: !repoHasQuestion,
+            addLabel: !issueHasQuestion,
+            removeLabel: false,
+            keepLabel: issueHasQuestion,
+            reason: 'open-questions',
+        };
+    }
+    if (issueHasQuestion) {
+        return {
+            label: QUESTION_LABEL,
+            createLabel: false,
+            addLabel: false,
+            removeLabel: true,
+            keepLabel: false,
+            reason: 'answered',
+        };
+    }
+    return {
+        label: QUESTION_LABEL,
+        createLabel: false,
+        addLabel: false,
+        removeLabel: false,
+        keepLabel: false,
+        reason: 'already-clear',
+    };
+}
+export async function auditLocalIssuesCli(args, cwd = process.cwd()) {
+    const parsed = parseArgs(args);
+    requireLocalProvider(parsed, 'issue-audit');
+    const issues = new LocalIssueProviderCore(localIssueRoot(cwd));
+    const limit = numberFlag(parsed, 'limit') ?? 50;
+    const result = await issues.listIssues({
+        limit,
+        cursor: stringFlag(parsed, 'cursor'),
+        filter: buildFilter(parsed),
+    });
+    const counts = {
+        open: result.issues.filter((issue) => issue.status === 'open').length,
+        closed: result.issues.filter((issue) => issue.status === 'closed').length,
+        archived: result.issues.filter((issue) => issue.status === 'archived').length,
+    };
+    if (parsed.flags.has('json')) {
+        console.log(JSON.stringify({ provider: 'local', limit, nextCursor: result.nextCursor, counts, issues: result.issues }, null, 2));
+        return;
+    }
+    console.log('# Issue Audit');
+    console.log('');
+    console.log('Scope: local .aiwg/issues/');
+    console.log(`Mode: ${parsed.flags.has('apply') ? 'apply requested, local audit is read-only' : 'read-only'}`);
+    console.log('');
+    console.log('## Counts');
+    console.log(`- Issues audited: ${result.issues.length}`);
+    console.log(`- Open: ${counts.open}`);
+    console.log(`- Closed: ${counts.closed}`);
+    console.log(`- Archived: ${counts.archived}`);
+    console.log('');
+    console.log('## Findings');
+    for (const issue of result.issues) {
+        console.log(`- ${issue.id} [${issue.status}/${issue.priority}] ${issue.title}`);
+    }
+    if (result.nextCursor)
+        console.log(`\nNext cursor: ${result.nextCursor}`);
+}
+function buildFilter(args) {
+    const expression = stringFlag(args, 'filter');
+    const filter = {};
+    if (expression) {
+        for (const token of expression.split(/\s+/).filter(Boolean)) {
+            const [key, value] = token.split(/:(.*)/s);
+            if (!value)
+                continue;
+            if (key === 'status')
+                filter.status = value;
+            else if (key === 'label')
+                filter.labels = [...(filter.labels ?? []), value];
+            else if (key === 'type')
+                filter.type = value;
+            else if (key === 'priority')
+                filter.priority = value;
+            else if (key === 'assignee')
+                filter.assignee = value;
+            else if (key === 'search')
+                filter.search = value;
+        }
+    }
+    filter.status = stringFlag(args, 'status') ?? filter.status;
+    const labels = csvFlag(args, 'label');
+    if (labels.length > 0)
+        filter.labels = [...(filter.labels ?? []), ...labels];
+    filter.type = stringFlag(args, 'type') ?? filter.type;
+    filter.priority = stringFlag(args, 'priority') ?? filter.priority;
+    filter.assignee = stringFlag(args, 'assignee') ?? filter.assignee;
+    filter.search = stringFlag(args, 'search') ?? filter.search;
+    return filter;
+}
+function requireLocalProvider(args, command) {
+    const provider = stringFlag(args, 'provider');
+    if (provider !== 'local') {
+        throw new Error(`${command} CLI workflow support is currently local-only; pass --provider local or use the configured external tracker workflow`);
+    }
+}
+function parseArgs(args) {
+    const positional = [];
+    const flags = new Map();
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg.startsWith('--')) {
+            positional.push(arg);
+            continue;
+        }
+        const [rawKey, inline] = arg.slice(2).split(/=(.*)/s).filter((part) => part !== undefined);
+        if (inline !== undefined && inline !== '') {
+            flags.set(rawKey, inline);
+            continue;
+        }
+        const next = args[i + 1];
+        if (next && !next.startsWith('--')) {
+            flags.set(rawKey, next);
+            i++;
+        }
+        else {
+            flags.set(rawKey, true);
+        }
+    }
+    return { positional, flags };
+}
+function stringFlag(args, name) {
+    const value = args.flags.get(name);
+    if (value === undefined || value === true)
+        return undefined;
+    return String(value);
+}
+function numberFlag(args, name) {
+    const value = stringFlag(args, name);
+    if (!value)
+        return undefined;
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed) || parsed < 1)
+        throw new Error(`--${name} must be a positive integer`);
+    return parsed;
+}
+function csvFlag(args, name) {
+    const value = stringFlag(args, name);
+    return value ? value.split(',').map((item) => item.trim()).filter(Boolean) : [];
+}
+//# sourceMappingURL=workflows.js.map

package/dist/src/kb/cli.js

@@ -0,0 +1,173 @@
+/**
+ * Knowledge Base CLI — `aiwg kb <subcommand>`
+ *
+ * Thin storage wrapper for the knowledge-base subsystem. Routes all
+ * persistence through `resolveStorage('kb')` so the KB honors
+ * `.aiwg/storage.config` redirection (Obsidian vault, Logseq graph, S3
+ * prefix, etc.) without each kb skill hardcoding `.aiwg/kb/`.
+ *
+ * Subcommands:
+ *   path [<subpath>]    Print resolved physical path to the KB root or a sub-entry
+ *   list [--prefix p]   List entries, optionally filtered
+ *   get <path>          Read an entry's content to stdout
+ *   put <path>          Write stdin contents to an entry (creates parents)
+ *   delete <path>       Delete an entry (no-op if missing)
+ *
+ * @design @.aiwg/architecture/storage-design.md (§4, §5)
+ * @issue #934
+ * @issue #965
+ */
+import { getLoadedConfig, resolveStorage } from '../storage/index.js';
+import { resolveSubsystemRoot } from '../storage/config.js';
+export async function main(args) {
+    const subcommand = args[0];
+    const subArgs = args.slice(1);
+    switch (subcommand) {
+        case 'path':
+            await handlePath(subArgs);
+            break;
+        case 'list':
+            await handleList(subArgs);
+            break;
+        case 'get':
+            await handleGet(subArgs);
+            break;
+        case 'put':
+            await handlePut(subArgs);
+            break;
+        case 'delete':
+            await handleDelete(subArgs);
+            break;
+        default:
+            printUsage();
+            if (subcommand) {
+                throw new Error(`Unknown kb subcommand: ${subcommand}`);
+            }
+    }
+}
+async function handlePath(args) {
+    const subpath = args.find((a) => !a.startsWith('--'));
+    const json = args.includes('--json');
+    const projectRoot = process.cwd();
+    const config = await getLoadedConfig(projectRoot);
+    // For non-fs backends, "path" is meaningless in the filesystem sense —
+    // tell the user, but still report the configured backend.
+    const backend = config?.backends?.['kb']?.type ?? 'fs';
+    if (backend !== 'fs') {
+        if (json) {
+            console.log(JSON.stringify({
+                backend,
+                note: `kb subsystem uses backend "${backend}" — physical filesystem path is not applicable. Use "aiwg kb get/list" instead.`,
+            }, null, 2));
+        }
+        else {
+            console.log(`kb backend: ${backend}`);
+            console.log(`  (filesystem path not applicable for this backend; use \`aiwg kb get/list\`)`);
+        }
+        return;
+    }
+    const root = resolveSubsystemRoot('kb', projectRoot, config);
+    const fullPath = subpath ? `${root}/${subpath}` : root;
+    if (json) {
+        console.log(JSON.stringify({ backend, root, path: fullPath }, null, 2));
+    }
+    else {
+        console.log(fullPath);
+    }
+}
+async function handleList(args) {
+    let prefix = '';
+    let json = false;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--prefix') {
+            prefix = args[++i] ?? '';
+        }
+        else if (args[i] === '--json') {
+            json = true;
+        }
+    }
+    const adapter = await resolveStorage('kb');
+    const entries = await adapter.list(prefix);
+    if (json) {
+        console.log(JSON.stringify(entries.map((e) => ({
+            path: e.path,
+            size: e.size,
+            modifiedAt: e.modifiedAt?.toISOString(),
+        })), null, 2));
+        return;
+    }
+    if (entries.length === 0) {
+        console.log(`No entries${prefix ? ` matching prefix "${prefix}"` : ''}.`);
+        return;
+    }
+    for (const e of entries) {
+        console.log(e.path);
+    }
+}
+async function handleGet(args) {
+    const path = args[0];
+    if (!path) {
+        throw new Error('Usage: aiwg kb get <path>');
+    }
+    const adapter = await resolveStorage('kb');
+    const content = await adapter.read(path);
+    if (content === null) {
+        throw new Error(`KB entry not found: ${path}`);
+    }
+    process.stdout.write(content);
+}
+async function handlePut(args) {
+    const path = args[0];
+    if (!path) {
+        throw new Error(`Usage: aiwg kb put <path>\n` +
+            `  Reads content from stdin. Creates parent directories. Overwrites existing.\n` +
+            `  Examples:\n` +
+            `    echo "# foo" | aiwg kb put entities/foo.md\n` +
+            `    cat draft.md | aiwg kb put concepts/bar.md`);
+    }
+    // Read stdin
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+    }
+    const content = Buffer.concat(chunks).toString('utf-8');
+    const adapter = await resolveStorage('kb');
+    await adapter.write(path, content);
+    console.log(`Wrote ${content.length} bytes to kb:${path}`);
+}
+async function handleDelete(args) {
+    const path = args[0];
+    if (!path) {
+        throw new Error('Usage: aiwg kb delete <path>');
+    }
+    const adapter = await resolveStorage('kb');
+    await adapter.delete(path);
+    console.log(`Deleted kb:${path} (no-op if missing)`);
+}
+function printUsage() {
+    console.log(`Usage: aiwg kb <subcommand>
+
+Subcommands:
+  path [<subpath>]      Print resolved physical path (fs backend only)
+  list [--prefix <p>]   List entries (optionally filtered by prefix)
+  get <path>            Read an entry's content to stdout
+  put <path>            Write stdin contents to an entry
+  delete <path>         Delete an entry (no-op if missing)
+
+Flags:
+  --json                Machine-readable output (path, list)
+
+Examples:
+  aiwg kb path                          # /home/user/proj/.aiwg/kb
+  aiwg kb path entities/foo.md          # ...absolute path
+  aiwg kb list --prefix entities/
+  aiwg kb get entities/foo.md
+  echo "# foo" | aiwg kb put entities/foo.md
+  aiwg kb delete entities/old.md
+
+The KB persists at .aiwg/kb/ on the default fs backend. Configure
+.aiwg/storage.config to redirect (#934). For non-fs backends (obsidian,
+logseq, etc.), \`aiwg kb path\` reports the backend rather than a
+filesystem path — use \`get\`/\`list\` to interact through the adapter.`);
+}
+//# sourceMappingURL=cli.js.map

package/dist/src/lint/cli.js

@@ -0,0 +1,171 @@
+/**
+ * Lint CLI Entry Point
+ *
+ * Parses CLI arguments and dispatches to the lint runner.
+ *
+ * Usage:
+ *   aiwg lint .aiwg/research/
+ *   aiwg lint .aiwg/research/ --ruleset research
+ *   aiwg lint --list-rulesets
+ *   aiwg lint --list-rules research
+ *   aiwg lint .aiwg/ --format json --ci --fail-on warn
+ *
+ * @issue #810
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { discoverRulesets } from './loader.js';
+import { autoDetectRulesets, runLint } from './runner.js';
+import { formatResult, formatRulesetList, formatRuleList } from './reporters.js';
+/**
+ * Resolve the AIWG install root — the directory containing `agentic/code/frameworks/`.
+ * Walks up from the running script's location so it works at any compiled depth
+ * (dev source vs `dist/src/lint/` vs an npm install path) without per-location math.
+ * Honors `AIWG_ROOT` env override first. Fixes #1515 (lint couldn't find rulesets
+ * when run outside the AIWG repo).
+ *
+ * Both markers (`agentic/code/frameworks/` AND `package.json`) must be present at
+ * the same level — that excludes stale `dist/agentic/` partials from prior builds
+ * (which exist without a sibling `package.json`).
+ */
+function findAiwgRoot() {
+    if (process.env.AIWG_ROOT)
+        return process.env.AIWG_ROOT;
+    let dir = path.dirname(fileURLToPath(import.meta.url));
+    while (dir !== path.dirname(dir)) {
+        if (fs.existsSync(path.join(dir, 'agentic', 'code', 'frameworks')) &&
+            fs.existsSync(path.join(dir, 'package.json'))) {
+            return dir;
+        }
+        dir = path.dirname(dir);
+    }
+    return process.cwd(); // last-resort fallback
+}
+const AIWG_ROOT = findAiwgRoot();
+/**
+ * Parse CLI arguments into LintOptions
+ */
+function parseArgs(args) {
+    const options = {
+        target: '',
+        recursive: true,
+        format: 'full',
+        ci: false,
+        failOn: 'error',
+        dryRun: false,
+        listRulesets: false,
+    };
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg === '--list-rulesets') {
+            options.listRulesets = true;
+        }
+        else if (arg === '--list-rules' && i + 1 < args.length) {
+            options.listRules = args[++i];
+        }
+        else if (arg === '--ruleset' && i + 1 < args.length) {
+            options.rulesets = args[++i].split(',').map(s => s.trim());
+        }
+        else if (arg === '--format' && i + 1 < args.length) {
+            options.format = args[++i];
+        }
+        else if (arg === '--ci') {
+            options.ci = true;
+        }
+        else if (arg === '--fail-on' && i + 1 < args.length) {
+            options.failOn = args[++i];
+        }
+        else if (arg === '--dry-run') {
+            options.dryRun = true;
+        }
+        else if (arg === '--recursive' || arg === '-r') {
+            options.recursive = true;
+        }
+        else if (arg === '--no-recursive') {
+            options.recursive = false;
+        }
+        else if (!arg.startsWith('-') && !options.target) {
+            options.target = arg;
+        }
+        i++;
+    }
+    return options;
+}
+/**
+ * Main lint CLI entry point
+ */
+export async function main(args) {
+    const options = parseArgs(args);
+    const cwd = process.cwd();
+    // Discover available rulesets. `cwd` is where the user runs the lint (used
+    // to find deployed `.aiwg/frameworks/*/lint/` overlays); `AIWG_ROOT` is the
+    // AIWG install (used to find shipped `agentic/code/frameworks/*/lint/`).
+    // Prior to #1515 this hardcoded both to `cwd`, which only worked inside the
+    // AIWG repo itself — user projects got an empty "Available:" list.
+    const allRulesets = await discoverRulesets(cwd, AIWG_ROOT);
+    // Handle --list-rulesets
+    if (options.listRulesets) {
+        console.log(formatRulesetList(allRulesets));
+        return;
+    }
+    // Handle --list-rules
+    if (options.listRules) {
+        const ruleset = allRulesets.find(r => r.id === options.listRules || r.framework === options.listRules);
+        if (!ruleset) {
+            console.error(`Ruleset '${options.listRules}' not found. Run 'aiwg lint --list-rulesets' to see available sets.`);
+            process.exitCode = 1;
+            return;
+        }
+        console.log(formatRuleList(ruleset));
+        return;
+    }
+    // Require a target for actual linting
+    if (!options.target) {
+        console.error('Usage: aiwg lint <target> [--ruleset <name>] [--format full|summary|json] [--ci] [--fail-on error|warn|info]');
+        console.error('       aiwg lint --list-rulesets');
+        console.error('       aiwg lint --list-rules <ruleset>');
+        process.exitCode = 1;
+        return;
+    }
+    // Resolve target path
+    const targetDir = path.resolve(cwd, options.target);
+    // Select rulesets
+    let selectedRulesets = allRulesets;
+    if (options.rulesets && options.rulesets.length > 0) {
+        selectedRulesets = allRulesets.filter(r => options.rulesets.includes(r.id) || options.rulesets.includes(r.framework));
+        if (selectedRulesets.length === 0) {
+            console.error(`No matching rulesets for: ${options.rulesets.join(', ')}`);
+            console.error('Available: ' + allRulesets.map(r => r.id).join(', '));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    else {
+        selectedRulesets = autoDetectRulesets(options.target, allRulesets);
+    }
+    // Dry run
+    if (options.dryRun) {
+        console.log(`Dry run: would lint '${options.target}' with rulesets: ${selectedRulesets.map(r => r.id).join(', ')}`);
+        for (const rs of selectedRulesets) {
+            console.log(`  ${rs.id}: ${rs.rules.length} rules`);
+            for (const rule of rs.rules) {
+                console.log(`    - ${rule.id} [${rule.severity}]: ${rule.description}`);
+            }
+        }
+        return;
+    }
+    // Run lint
+    const result = await runLint(targetDir, selectedRulesets, {
+        recursive: options.recursive,
+        failOn: options.failOn,
+    });
+    // Output results
+    console.log(formatResult(result, options.format || 'full'));
+    // Set exit code in CI mode
+    if (options.ci && !result.summary.passed) {
+        process.exitCode = 1;
+    }
+}
+//# sourceMappingURL=cli.js.map