@shrkcrft/cli 0.1.0-alpha.2

package/dist/commands/import.command.d.ts

@@ -0,0 +1,3 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const importCommand: ICommandHandler;
+//# sourceMappingURL=import.command.d.ts.map

package/dist/commands/import.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import.command.d.ts","sourceRoot":"","sources":["../../src/commands/import.command.ts"],"names":[],"mappings":"AASA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAyBhC,eAAO,MAAM,aAAa,EAAE,eA8G3B,CAAC"}

package/dist/commands/import.command.js

@@ -0,0 +1,115 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { emitKnowledgeTs, importAgentsMd, importClaudeMd, importCursorRules, } from '@shrkcrft/importer';
+import { flagBool, flagString, flagList, resolveCwd, } from "../command-registry.js";
+import { asJson, header, kv } from "../output/format-output.js";
+function repeatedFlagList(args, name) {
+    return flagList(args, name, { dedupe: true });
+}
+const KNOWN_FORMATS = ['agents-md', 'claude-md', 'cursor-rules'];
+function defaultSource(format) {
+    switch (format) {
+        case 'agents-md':
+            return 'AGENTS.md';
+        case 'claude-md':
+            return 'CLAUDE.md';
+        case 'cursor-rules':
+            return '.cursor/rules';
+    }
+}
+function defaultOutput(format) {
+    return `sharkcraft/imports/${format}-import.draft.ts`;
+}
+export const importCommand = {
+    name: 'import',
+    description: 'Parse existing agent rule files (AGENTS.md / CLAUDE.md / .cursor/rules) into a structured @shrkcrft/knowledge TypeScript draft. Dry-run by default; --write saves the draft to sharkcraft/imports/.',
+    usage: 'shrk [--cwd <dir>] import <format> [<path>] [--prefix <id>] [--tag <t>] [--scope <s>] [--output <file>] [--write] [--force] [--json]',
+    async run(args) {
+        const format = args.positional[0];
+        if (!format || !KNOWN_FORMATS.includes(format)) {
+            process.stderr.write(`Usage: shrk import <format> [<path>]\nFormats: ${KNOWN_FORMATS.join(', ')}\n`);
+            return 2;
+        }
+        const fmt = format;
+        const cwd = resolveCwd(args);
+        const path = args.positional[1] ?? defaultSource(fmt);
+        const prefix = flagString(args, 'prefix');
+        const extraTags = repeatedFlagList(args, 'tag');
+        const scope = repeatedFlagList(args, 'scope');
+        const base = {
+            filePath: path,
+            projectRoot: cwd,
+            ...(prefix !== undefined ? { idPrefix: prefix } : {}),
+            ...(extraTags.length ? { extraTags } : {}),
+            ...(scope.length ? { scope } : {}),
+        };
+        let result;
+        switch (fmt) {
+            case 'agents-md':
+                result = importAgentsMd(base);
+                break;
+            case 'claude-md':
+                result = importClaudeMd(base);
+                break;
+            case 'cursor-rules':
+                result = importCursorRules(base);
+                break;
+        }
+        const outPath = nodePath.resolve(cwd, flagString(args, 'output') ?? flagString(args, 'out') ?? defaultOutput(fmt));
+        const write = flagBool(args, 'write');
+        const tsSource = emitKnowledgeTs(result.entries, {
+            sourceLabel: `${fmt} (${result.sourceFiles.join(', ') || path})`,
+        });
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({
+                format: fmt,
+                source: path,
+                out: outPath,
+                write,
+                entryCount: result.entries.length,
+                warnings: result.warnings,
+                entries: result.entries.map(({ content: _, ...meta }) => meta),
+            }) + '\n');
+            return result.entries.length === 0 ? 1 : 0;
+        }
+        process.stdout.write(header(`Import (${fmt})`));
+        process.stdout.write(kv('source', path) + '\n');
+        process.stdout.write(kv('files read', String(result.sourceFiles.length)) + '\n');
+        process.stdout.write(kv('entries parsed', String(result.entries.length)) + '\n');
+        if (prefix)
+            process.stdout.write(kv('id prefix', prefix) + '\n');
+        if (extraTags.length)
+            process.stdout.write(kv('extra tags', extraTags.join(', ')) + '\n');
+        if (scope.length)
+            process.stdout.write(kv('scope', scope.join(', ')) + '\n');
+        process.stdout.write(kv('output', outPath) + '\n');
+        process.stdout.write(kv('mode', write ? 'write' : 'dry-run (preview only)') + '\n\n');
+        if (result.warnings.length > 0) {
+            process.stdout.write(header('Warnings'));
+            for (const w of result.warnings) {
+                process.stdout.write(`  ${w.origin}: ${w.message}\n`);
+            }
+            process.stdout.write('\n');
+        }
+        if (result.entries.length === 0) {
+            process.stderr.write('No entries parsed.\n');
+            return 1;
+        }
+        if (!write) {
+            process.stdout.write(header('Preview (first 30 lines of generated TS)'));
+            const preview = tsSource.split('\n').slice(0, 30).join('\n');
+            process.stdout.write(preview + '\n');
+            process.stdout.write(`\n--- (preview truncated; total ${tsSource.split('\n').length} lines) ---\n`);
+            process.stdout.write('\nRe-run with --write to persist.\n');
+            return 0;
+        }
+        mkdirSync(nodePath.dirname(outPath), { recursive: true });
+        if (existsSync(outPath) && !flagBool(args, 'force')) {
+            process.stderr.write(`Refusing to overwrite ${outPath}. Pass --force or pick a different --out.\n`);
+            return 1;
+        }
+        writeFileSync(outPath, tsSource, 'utf8');
+        process.stdout.write(`Wrote ${outPath}\n`);
+        return 0;
+    },
+};

package/dist/commands/infer.command.d.ts

@@ -0,0 +1,3 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const inferCommand: ICommandHandler;
+//# sourceMappingURL=infer.command.d.ts.map

package/dist/commands/infer.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer.command.d.ts","sourceRoot":"","sources":["../../src/commands/infer.command.ts"],"names":[],"mappings":"AAYA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AA2BhC,eAAO,MAAM,YAAY,EAAE,eAe1B,CAAC"}

package/dist/commands/infer.command.js

@@ -0,0 +1,227 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { inferTemplateBodyV2, inspectSharkcraft, loadScaffoldPatternsFromInspection, matchScaffoldPattern, extractVariablesForFile, } from '@shrkcrft/inspector';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson, header } from "../output/format-output.js";
+const KIND_MAP = {
+    service: 'service',
+    services: 'service',
+    utility: 'utility',
+    utilities: 'utility',
+    util: 'utility',
+    test: 'test',
+    tests: 'test',
+    spec: 'test',
+    component: 'component',
+    components: 'component',
+};
+export const inferCommand = {
+    name: 'infer',
+    description: 'Inference helpers (templates / boundaries). `shrk infer templates --ast` produces template-body draft candidates using the TypeScript compiler API when available, with scaffold-pattern–driven detection from installed packs.',
+    usage: 'shrk [--cwd <dir>] infer templates [--ast] [--kind service|utility|test|component] [--include <glob>] [--limit N] [--json]',
+    async run(args) {
+        const sub = args.positional[0];
+        if (sub === 'templates') {
+            const sliced = { ...args, positional: args.positional.slice(1) };
+            return runInferTemplates(sliced);
+        }
+        process.stderr.write('Usage: shrk infer templates [--ast] [...]\n');
+        return 2;
+    },
+};
+async function runInferTemplates(args) {
+    const cwd = resolveCwd(args);
+    const useAst = flagBool(args, 'ast');
+    const wantJson = flagBool(args, 'json');
+    const kindRaw = flagString(args, 'kind');
+    const kind = kindRaw && KIND_MAP[kindRaw.toLowerCase()]
+        ? KIND_MAP[kindRaw.toLowerCase()]
+        : 'service';
+    const limit = parseInt(flagString(args, 'limit') ?? '5', 10);
+    const includeGlob = flagString(args, 'include');
+    const inspection = await inspectSharkcraft({ cwd });
+    const patterns = await loadScaffoldPatternsFromInspection(inspection);
+    // Walk candidate files: when scaffold patterns exist, use their match paths
+    // as the seed set; otherwise scan src/ for files matching the kind.
+    const candidates = collectCandidateFiles({
+        cwd,
+        inspection,
+        patterns: patterns.patterns,
+        kind,
+        includeGlob,
+    });
+    if (candidates.length === 0) {
+        if (wantJson) {
+            process.stdout.write(asJson({ candidates: [], note: 'no candidate files found' }) + '\n');
+        }
+        else {
+            process.stdout.write('No candidate files found.\n');
+        }
+        return 0;
+    }
+    const out = [];
+    for (const c of candidates.slice(0, Math.max(1, limit))) {
+        const relPath = nodePath.relative(cwd, c.absPath).split(nodePath.sep).join('/');
+        const candidate = {
+            schema: 'sharkcraft.inferred-template-candidate/v2',
+            sample: relPath,
+            variables: {},
+            warnings: [],
+        };
+        // Scaffold-pattern match (if any).
+        if (c.pattern) {
+            const ext = extractVariablesForFile(c.pattern.pattern, relPath, inspection);
+            candidate.matchedPattern = {
+                id: c.pattern.pattern.id,
+                templateId: c.pattern.pattern.templateId,
+                source: c.pattern.source.packageName ?? c.pattern.source.type,
+                confidence: c.pattern.pattern.confidence,
+            };
+            candidate.variables = ext.values;
+            candidate.warnings.push(...ext.warnings);
+            candidate.suggestedCommand = buildSuggestedCommand(c.pattern.pattern.templateId, ext.values);
+        }
+        if (useAst) {
+            const v2 = await inferTemplateBodyV2({
+                projectRoot: cwd,
+                sample: relPath,
+                kind,
+            });
+            if (v2.scaffold)
+                candidate.scaffold = v2.scaffold;
+            else if (v2.reason)
+                candidate.warnings.push(v2.reason);
+        }
+        out.push(candidate);
+    }
+    if (wantJson) {
+        process.stdout.write(asJson({
+            candidates: out,
+            scaffoldPatternsConsidered: patterns.patterns.length,
+            warnings: patterns.warnings,
+        }) + '\n');
+        return 0;
+    }
+    process.stdout.write(header(`Template inference (${useAst ? 'ast' : 'pattern-only'})`));
+    for (const c of out) {
+        process.stdout.write(`\n  sample      ${c.sample}\n`);
+        if (c.matchedPattern) {
+            process.stdout.write(`  pattern     ${c.matchedPattern.id}  → ${c.matchedPattern.templateId} (${c.matchedPattern.confidence}, from ${c.matchedPattern.source})\n`);
+        }
+        if (Object.keys(c.variables).length > 0) {
+            process.stdout.write(`  vars        ${Object.entries(c.variables).map(([k, v]) => `${k}=${v}`).join(', ')}\n`);
+        }
+        if (c.scaffold) {
+            process.stdout.write(`  ast         ${c.scaffold.provenance}  (confidence=${c.scaffold.confidence})\n`);
+            for (const r of c.scaffold.confidenceReasons.slice(0, 2))
+                process.stdout.write(`              · ${r}\n`);
+        }
+        if (c.suggestedCommand)
+            process.stdout.write(`  suggested   ${c.suggestedCommand}\n`);
+        for (const w of c.warnings.slice(0, 2))
+            process.stdout.write(`  warn        ${w}\n`);
+    }
+    return 0;
+}
+function collectCandidateFiles(input) {
+    const seen = new Map();
+    // 1. Scaffold-pattern matches.
+    if (input.patterns.length > 0) {
+        walk(input.cwd, (abs, rel) => {
+            for (const p of input.patterns) {
+                if (matchScaffoldPattern(p.pattern, rel)) {
+                    if (!seen.has(abs))
+                        seen.set(abs, { absPath: abs, pattern: p });
+                    return;
+                }
+            }
+        });
+    }
+    // 2. Generic kind-based scan if there are no matches yet.
+    if (seen.size === 0) {
+        const dirToken = kindToDir(input.kind);
+        walk(input.cwd, (abs, rel) => {
+            if (rel.includes(`/${dirToken}/`) && /\.(tsx?|jsx?)$/.test(abs)) {
+                if (!seen.has(abs))
+                    seen.set(abs, { absPath: abs });
+            }
+        });
+    }
+    let out = [...seen.values()];
+    if (input.includeGlob) {
+        const re = globRe(input.includeGlob);
+        out = out.filter((c) => re.test(nodePath.relative(input.cwd, c.absPath).split(nodePath.sep).join('/')));
+    }
+    return out;
+}
+function kindToDir(kind) {
+    switch (kind) {
+        case 'service':
+            return 'services';
+        case 'utility':
+            return 'utils';
+        case 'test':
+            return 'tests';
+        case 'component':
+            return 'components';
+    }
+}
+function walk(root, onFile) {
+    const visit = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (e === 'node_modules' || e === '.git' || e === 'dist' || e === '.sharkcraft' || e === '__tests__')
+                continue;
+            const full = nodePath.join(dir, e);
+            let st;
+            try {
+                st = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory())
+                visit(full);
+            else if (st.isFile()) {
+                const rel = nodePath.relative(root, full).split(nodePath.sep).join('/');
+                onFile(full, rel);
+            }
+        }
+    };
+    if (existsSync(root))
+        visit(root);
+}
+function globRe(g) {
+    let re = '^';
+    for (let i = 0; i < g.length; i += 1) {
+        const c = g[i];
+        if (c === '*' && g[i + 1] === '*') {
+            re += '.*';
+            i += 1;
+        }
+        else if (c === '*')
+            re += '[^/]*';
+        else if (c === '?')
+            re += '[^/]';
+        else if ('.+()[]{}|^$\\'.includes(c))
+            re += '\\' + c;
+        else
+            re += c;
+    }
+    re += '$';
+    return new RegExp(re);
+}
+function buildSuggestedCommand(templateId, vars) {
+    const name = vars.name ?? '<name>';
+    const flags = Object.entries(vars)
+        .filter(([k]) => k !== 'name')
+        .map(([k, v]) => `--var ${k}=${v}`)
+        .join(' ');
+    return `shrk gen ${templateId} ${name}${flags ? ' ' + flags : ''} --dry-run --save-plan /tmp/${templateId}.plan.json`;
+}

package/dist/commands/ingest.command.d.ts

@@ -0,0 +1,6 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const ingestCommand: ICommandHandler;
+export declare const contradictionsCommand: ICommandHandler;
+export declare const generatedCommand: ICommandHandler;
+export declare const stabilityCommand: ICommandHandler;
+//# sourceMappingURL=ingest.command.d.ts.map

package/dist/commands/ingest.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingest.command.d.ts","sourceRoot":"","sources":["../../src/commands/ingest.command.ts"],"names":[],"mappings":"AAyCA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAOhC,eAAO,MAAM,aAAa,EAAE,eA4B3B,CAAC;AAmZF,eAAO,MAAM,qBAAqB,EAAE,eAenC,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,eA8B9B,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,eAkC9B,CAAC"}