@shrkcrft/cli 0.1.0-alpha.2

package/dist/init/detected-block.d.ts

@@ -0,0 +1,57 @@
+import { type IWorkspaceSummary } from '@shrkcrft/workspace';
+export declare enum DetectedConfidence {
+    Detected = "detected",
+    Inferred = "inferred",
+    NotFound = "not-found"
+}
+export interface IDetectedRow {
+    key: string;
+    value: string;
+    confidence: DetectedConfidence;
+    evidence?: string;
+}
+export interface IDetectedRoots {
+    source: readonly string[];
+    test: readonly string[];
+    packages: readonly string[];
+    generated: readonly string[];
+}
+export interface IDetectedScripts {
+    build: string | null;
+    test: string | null;
+    typecheck: string | null;
+    lint: string | null;
+    start: string | null;
+}
+export interface IDetectedConfigs {
+    tsconfig: boolean;
+    eslint: boolean;
+    biome: boolean;
+    githubActions: boolean;
+    nx: boolean;
+    turbo: boolean;
+}
+export interface IDetectedPresetPick {
+    presetId: string;
+    title: string;
+    confidence: 'high' | 'medium' | 'low';
+    reasons: readonly string[];
+}
+export interface IDetectedBlock {
+    workspaceFlavor: string;
+    packageManager: string;
+    frameworks: readonly string[];
+    hasTypeScript: boolean;
+    roots: IDetectedRoots;
+    scripts: IDetectedScripts;
+    configs: IDetectedConfigs;
+    recommendedPreset: IDetectedPresetPick | null;
+    notGuessed: readonly string[];
+}
+export declare function buildDetectedBlock(cwd: string, summary: IWorkspaceSummary): IDetectedBlock;
+/**
+ * Render the Detected block as plain text lines (one per line, no
+ * trailing newline). Callers add their own header / spacing.
+ */
+export declare function renderDetectedBlockText(block: IDetectedBlock): string;
+//# sourceMappingURL=detected-block.d.ts.map

package/dist/init/detected-block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detected-block.d.ts","sourceRoot":"","sources":["../../src/init/detected-block.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAoB,KAAK,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAG/E,oBAAY,kBAAkB;IAC5B,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,QAAQ,cAAc;CACvB;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,kBAAkB,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;IACf,aAAa,EAAE,OAAO,CAAC;IACvB,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACtC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,cAAc;IAC7B,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,aAAa,EAAE,OAAO,CAAC;IACvB,KAAK,EAAE,cAAc,CAAC;IACtB,OAAO,EAAE,gBAAgB,CAAC;IAC1B,OAAO,EAAE,gBAAgB,CAAC;IAC1B,iBAAiB,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC9C,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/B;AAmHD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,cAAc,CAe1F;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CA0DrE"}

package/dist/init/detected-block.js

@@ -0,0 +1,197 @@
+/**
+ * Shared "Detected" block builder used by `shrk inspect` and
+ * `shrk init`.
+ *
+ * Given the workspace summary and the cwd, this produces a structured
+ * snapshot of what SharkCraft can detect about the project without
+ * touching any config it has not been asked to touch. The block is
+ * read-only; it never writes files and never executes scripts.
+ *
+ * Why a shared module: both `inspect` and `init` need the same
+ * detection summary to give the user a coherent first-60-second story
+ * — "here is what I see; here is what I will do next". Duplicating it
+ * across two command files makes it drift.
+ */
+import { existsSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { WorkspaceProfile } from '@shrkcrft/workspace';
+import { BUILTIN_PRESETS, recommendPresets } from '@shrkcrft/presets';
+export var DetectedConfidence;
+(function (DetectedConfidence) {
+    DetectedConfidence["Detected"] = "detected";
+    DetectedConfidence["Inferred"] = "inferred";
+    DetectedConfidence["NotFound"] = "not-found";
+})(DetectedConfidence || (DetectedConfidence = {}));
+const SOURCE_DIR_CANDIDATES = ['src', 'lib', 'app', 'source'];
+const TEST_DIR_CANDIDATES = ['tests', 'test', '__tests__', 'spec', 'specs'];
+const PACKAGE_DIR_CANDIDATES = ['packages', 'libs', 'apps'];
+const GENERATED_DIR_CANDIDATES = ['dist', 'build', 'out', 'coverage', '.next', '.turbo'];
+function fileExists(root, rel) {
+    return existsSync(nodePath.join(root, rel));
+}
+function detectRoots(cwd) {
+    return {
+        source: SOURCE_DIR_CANDIDATES.filter((d) => fileExists(cwd, d)),
+        test: TEST_DIR_CANDIDATES.filter((d) => fileExists(cwd, d)),
+        packages: PACKAGE_DIR_CANDIDATES.filter((d) => fileExists(cwd, d)),
+        generated: GENERATED_DIR_CANDIDATES.filter((d) => fileExists(cwd, d)),
+    };
+}
+function pickScript(scripts, prefer, contains) {
+    for (const name of prefer) {
+        if (typeof scripts[name] === 'string' && scripts[name].trim() !== '')
+            return name;
+    }
+    for (const [name, body] of Object.entries(scripts)) {
+        if (typeof body !== 'string')
+            continue;
+        for (const needle of contains) {
+            if (body.includes(needle) || name.includes(needle))
+                return name;
+        }
+    }
+    return null;
+}
+function detectScripts(summary) {
+    const scripts = summary.scripts;
+    return {
+        build: pickScript(scripts, ['build', 'build:dist'], ['build']),
+        test: pickScript(scripts, ['test'], ['bun test', 'jest', 'vitest', 'mocha']),
+        typecheck: pickScript(scripts, ['typecheck', 'tsc', 'type-check'], ['tsc']),
+        lint: pickScript(scripts, ['lint'], ['eslint', 'biome']),
+        start: pickScript(scripts, ['start', 'dev', 'serve'], ['start', 'serve', 'dev']),
+    };
+}
+function detectConfigs(cwd, summary) {
+    return {
+        tsconfig: summary.tsConfig !== null,
+        eslint: fileExists(cwd, '.eslintrc') ||
+            fileExists(cwd, '.eslintrc.js') ||
+            fileExists(cwd, '.eslintrc.cjs') ||
+            fileExists(cwd, '.eslintrc.json') ||
+            fileExists(cwd, '.eslintrc.yaml') ||
+            fileExists(cwd, '.eslintrc.yml') ||
+            fileExists(cwd, 'eslint.config.js') ||
+            fileExists(cwd, 'eslint.config.mjs') ||
+            fileExists(cwd, 'eslint.config.cjs') ||
+            fileExists(cwd, 'eslint.config.ts') ||
+            summary.profiles.includes(WorkspaceProfile.HasEslint),
+        biome: fileExists(cwd, 'biome.json') ||
+            fileExists(cwd, 'biome.jsonc') ||
+            summary.profiles.includes(WorkspaceProfile.HasBiome),
+        githubActions: fileExists(cwd, '.github/workflows') ||
+            summary.profiles.includes(WorkspaceProfile.HasGithubActions),
+        nx: summary.profiles.includes(WorkspaceProfile.HasNx) || fileExists(cwd, 'nx.json'),
+        turbo: summary.profiles.includes(WorkspaceProfile.HasTurborepo) || fileExists(cwd, 'turbo.json'),
+    };
+}
+function detectWorkspaceFlavor(summary, configs) {
+    if (configs.nx)
+        return 'Nx workspace';
+    if (configs.turbo)
+        return 'Turborepo workspace';
+    if (summary.profiles.includes(WorkspaceProfile.HasPackageWorkspaces)) {
+        return 'npm/pnpm/yarn workspaces';
+    }
+    if (summary.profiles.includes(WorkspaceProfile.IsMonorepo)) {
+        return 'monorepo (untyped)';
+    }
+    return 'single package';
+}
+function pickRecommendedPreset(summary) {
+    const recs = recommendPresets([...BUILTIN_PRESETS], {
+        profiles: summary.profiles,
+        limit: 1,
+    });
+    const top = recs[0];
+    if (!top)
+        return null;
+    const preset = top.preset;
+    return {
+        presetId: preset.id,
+        title: preset.title,
+        confidence: top.confidence,
+        reasons: top.reasons,
+    };
+}
+function notGuessedFor(roots, configs) {
+    const missing = [];
+    if (roots.source.length === 0)
+        missing.push('source roots (no src/lib/app dir detected)');
+    if (roots.test.length === 0)
+        missing.push('test roots (no tests/test/__tests__ dir detected)');
+    if (!configs.tsconfig)
+        missing.push('tsconfig.json (no TypeScript config detected)');
+    if (!configs.eslint && !configs.biome) {
+        missing.push('lint config (no ESLint or Biome config detected)');
+    }
+    return missing;
+}
+export function buildDetectedBlock(cwd, summary) {
+    const roots = detectRoots(cwd);
+    const configs = detectConfigs(cwd, summary);
+    const scripts = detectScripts(summary);
+    return {
+        workspaceFlavor: detectWorkspaceFlavor(summary, configs),
+        packageManager: summary.packageManager.manager,
+        frameworks: summary.frameworks.map((f) => f.name),
+        hasTypeScript: summary.hasTypeScript,
+        roots,
+        scripts,
+        configs,
+        recommendedPreset: pickRecommendedPreset(summary),
+        notGuessed: notGuessedFor(roots, configs),
+    };
+}
+/**
+ * Render the Detected block as plain text lines (one per line, no
+ * trailing newline). Callers add their own header / spacing.
+ */
+export function renderDetectedBlockText(block) {
+    const lines = [];
+    const pad = (k) => `  ${k.padEnd(20)}`;
+    lines.push(`${pad('workspace flavor')} ${block.workspaceFlavor}`);
+    lines.push(`${pad('package manager')} ${block.packageManager}`);
+    lines.push(`${pad('frameworks')} ${block.frameworks.length ? block.frameworks.join(', ') : '(none)'}`);
+    lines.push(`${pad('typescript')} ${block.hasTypeScript ? 'yes' : 'no'}`);
+    lines.push(`${pad('source roots')} ${block.roots.source.length ? block.roots.source.join(', ') : '(not detected)'}`);
+    lines.push(`${pad('test roots')} ${block.roots.test.length ? block.roots.test.join(', ') : '(not detected)'}`);
+    if (block.roots.packages.length) {
+        lines.push(`${pad('package roots')} ${block.roots.packages.join(', ')}`);
+    }
+    if (block.roots.generated.length) {
+        lines.push(`${pad('generated dirs')} ${block.roots.generated.join(', ')}`);
+    }
+    lines.push(`${pad('scripts')} ${[
+        block.scripts.build && `build=${block.scripts.build}`,
+        block.scripts.test && `test=${block.scripts.test}`,
+        block.scripts.typecheck && `typecheck=${block.scripts.typecheck}`,
+        block.scripts.lint && `lint=${block.scripts.lint}`,
+        block.scripts.start && `start=${block.scripts.start}`,
+    ]
+        .filter(Boolean)
+        .join(' ') || '(none detected)'}`);
+    lines.push(`${pad('configs')} ${[
+        block.configs.tsconfig && 'tsconfig',
+        block.configs.eslint && 'eslint',
+        block.configs.biome && 'biome',
+        block.configs.githubActions && 'github-actions',
+        block.configs.nx && 'nx.json',
+        block.configs.turbo && 'turbo.json',
+    ]
+        .filter(Boolean)
+        .join(', ') || '(none detected)'}`);
+    if (block.recommendedPreset) {
+        lines.push(`${pad('recommended preset')} ${block.recommendedPreset.presetId} (${block.recommendedPreset.confidence})`);
+    }
+    else {
+        lines.push(`${pad('recommended preset')} (none matched — would fall back to generic)`);
+    }
+    if (block.notGuessed.length) {
+        lines.push('  not guessed:');
+        for (const n of block.notGuessed) {
+            lines.push(`    • ${n}`);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/init/gitignore.d.ts

@@ -0,0 +1,30 @@
+/** Patterns SharkCraft needs ignored. Order is stable for diff output. */
+export declare const SHARKCRAFT_GITIGNORE_PATTERNS: readonly string[];
+export interface IGitignorePatch {
+    /** Absolute path of the .gitignore file (created or updated). */
+    readonly path: string;
+    /** True if the file did not exist before this call. */
+    readonly created: boolean;
+    /** Patterns that were already present before this call. */
+    readonly alreadyPresent: readonly string[];
+    /** Patterns that this patch adds. Empty when nothing to do. */
+    readonly added: readonly string[];
+    /** New file body the patch would write (or wrote, when `dryRun: false`). */
+    readonly nextBody: string;
+    /** True if `dryRun: false` actually wrote. */
+    readonly wrote: boolean;
+}
+export interface IGitignorePatchOptions {
+    /** Project root that owns the `.gitignore`. */
+    readonly cwd: string;
+    /** When true, compute the patch without writing. Default true. */
+    readonly dryRun?: boolean;
+}
+/**
+ * Computes (and optionally applies) the gitignore patch that ensures all
+ * SharkCraft local-state directories are ignored. Idempotent.
+ */
+export declare function ensureSharkcraftGitignore(options: IGitignorePatchOptions): IGitignorePatch;
+/** Render a short human summary of the patch. */
+export declare function renderGitignorePatch(patch: IGitignorePatch, dryRun: boolean): string;
+//# sourceMappingURL=gitignore.d.ts.map

package/dist/init/gitignore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gitignore.d.ts","sourceRoot":"","sources":["../../src/init/gitignore.ts"],"names":[],"mappings":"AAeA,0EAA0E;AAC1E,eAAO,MAAM,6BAA6B,EAAE,SAAS,MAAM,EAY1D,CAAC;AAKF,MAAM,WAAW,eAAe;IAC9B,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,uDAAuD;IACvD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,2DAA2D;IAC3D,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,+DAA+D;IAC/D,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,4EAA4E;IAC5E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8CAA8C;IAC9C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,sBAAsB;IACrC,+CAA+C;IAC/C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,kEAAkE;IAClE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,sBAAsB,GAC9B,eAAe,CA+DjB;AAED,iDAAiD;AACjD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,CAapF"}

package/dist/init/gitignore.js

@@ -0,0 +1,110 @@
+/**
+ * `.gitignore` safety for SharkCraft local state.
+ *
+ * `init` (any preset path) and `doctor --check-gitignore` rely on this to
+ * make sure the directories SharkCraft writes locally — sessions, reports,
+ * fixes, authoring drafts, memory snapshots, tmp, cache — never land in
+ * commits by accident. Project-config under `sharkcraft/` (the
+ * deterministic input the engine consumes) stays committed.
+ *
+ *   Idempotent: running the patch twice is a no-op.
+ *   Preview-first: callers pass `dryRun: true` to inspect the diff.
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+/** Patterns SharkCraft needs ignored. Order is stable for diff output. */
+export const SHARKCRAFT_GITIGNORE_PATTERNS = [
+    '.sharkcraft/sessions/',
+    '.sharkcraft/reports/',
+    '.sharkcraft/fixes/',
+    '.sharkcraft/authoring/',
+    '.sharkcraft/memory/',
+    '.sharkcraft/tmp/',
+    '.sharkcraft/cache/',
+    // Local-only command usage log (writes only; no exfiltration).
+    '.sharkcraft/usage/',
+    // Cached project-shape detection.
+    '.sharkcraft/shape.json',
+];
+const MARKER_START = '# >>> sharkcraft local state (managed by `shrk init`)';
+const MARKER_END = '# <<< sharkcraft local state';
+/**
+ * Computes (and optionally applies) the gitignore patch that ensures all
+ * SharkCraft local-state directories are ignored. Idempotent.
+ */
+export function ensureSharkcraftGitignore(options) {
+    const cwd = options.cwd;
+    const dryRun = options.dryRun !== false;
+    const filePath = nodePath.join(cwd, '.gitignore');
+    const existingBody = existsSync(filePath) ? readFileSync(filePath, 'utf8') : '';
+    const created = existingBody.length === 0;
+    const existingLines = existingBody.split(/\r?\n/);
+    const presentSet = new Set();
+    for (const line of existingLines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        presentSet.add(trimmed);
+    }
+    const alreadyPresent = [];
+    const toAdd = [];
+    for (const pattern of SHARKCRAFT_GITIGNORE_PATTERNS) {
+        if (presentSet.has(pattern))
+            alreadyPresent.push(pattern);
+        else
+            toAdd.push(pattern);
+    }
+    if (toAdd.length === 0) {
+        return {
+            path: filePath,
+            created: false,
+            alreadyPresent,
+            added: [],
+            nextBody: existingBody,
+            wrote: false,
+        };
+    }
+    const block = [
+        MARKER_START,
+        ...toAdd,
+        MARKER_END,
+    ].join('\n');
+    // Append the managed block; preserve trailing newline behaviour.
+    let nextBody;
+    if (existingBody.length === 0) {
+        nextBody = block + '\n';
+    }
+    else {
+        const needsLeadingNewline = !existingBody.endsWith('\n');
+        nextBody = existingBody + (needsLeadingNewline ? '\n\n' : '\n') + block + '\n';
+    }
+    let wrote = false;
+    if (!dryRun) {
+        writeFileSync(filePath, nextBody, 'utf8');
+        wrote = true;
+    }
+    return {
+        path: filePath,
+        created,
+        alreadyPresent,
+        added: toAdd,
+        nextBody,
+        wrote,
+    };
+}
+/** Render a short human summary of the patch. */
+export function renderGitignorePatch(patch, dryRun) {
+    const lines = [];
+    lines.push(`.gitignore — ${dryRun ? 'preview' : 'updated'}`);
+    lines.push(`  file:           ${patch.path}`);
+    lines.push(`  created file:   ${patch.created ? 'yes' : 'no'}`);
+    lines.push(`  patterns kept:  ${patch.alreadyPresent.length}`);
+    lines.push(`  patterns added: ${patch.added.length}`);
+    if (patch.added.length > 0) {
+        lines.push('');
+        lines.push('  Would add:');
+        for (const p of patch.added)
+            lines.push(`    + ${p}`);
+    }
+    return lines.join('\n') + '\n';
+}

package/dist/init/init-templates.d.ts

@@ -0,0 +1,6 @@
+export interface IInitFile {
+    relativePath: string;
+    content: string;
+}
+export declare const INIT_FILES: readonly IInitFile[];
+//# sourceMappingURL=init-templates.d.ts.map

package/dist/init/init-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-templates.d.ts","sourceRoot":"","sources":["../../src/init/init-templates.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,UAAU,EAAE,SAAS,SAAS,EA4Z1C,CAAC"}