@shrkcrft/cli 0.1.0-alpha.8 → 0.1.0-alpha.9

package/dist/export/export-formats.js

@@ -1,28 +1,11 @@
 import { aggregateActionHints, KnowledgeType } from '@shrkcrft/knowledge';
 import { priorityWeight } from '@shrkcrft/knowledge';
-function projectSlug(name) {
-    if (!name)
-        return 'project';
-    return (name
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .slice(0, 48) || 'project');
-}
-function defaultOutputFor(format, inspection) {
-    switch (format) {
-        case 'agents-md':
-            return 'AGENTS.md';
-        case 'claude-md':
-            return 'CLAUDE.md';
-        case 'claude-skill':
-            return `.claude/skills/${projectSlug(inspection.config?.projectName)}/SKILL.md`;
-        case 'cursor-rules':
-            return '.cursor/rules/sharkcraft.mdc';
-        case 'copilot-instructions':
-            return '.github/copilot-instructions.md';
-    }
-}
+const DEFAULT_OUTPUT_PATH = {
+    'agents-md': 'AGENTS.md',
+    'claude-md': 'CLAUDE.md',
+    'cursor-rules': '.cursor/rules/sharkcraft.mdc',
+    'copilot-instructions': '.github/copilot-instructions.md',
+};
 function selectTopByPriority(entries, limit) {
     return [...entries]
         .sort((a, b) => priorityWeight(b.priority) - priorityWeight(a.priority))
@@ -117,131 +100,23 @@ function renderBody(inspection, options) {
     }
     return sections.join('\n\n');
 }
-/**
- * Filter rules / paths to the high-signal subset for an inlined skill.
- *
- * Every rule the skill carries pays in Claude's context every time the
- * skill is loaded. Low-priority items dilute the signal of the
- * load-bearing ones (`Critical` safety + `High` architecture). We keep
- * only Critical + High by default, falling back to "all" only if the
- * filtered list is empty (e.g. a repo with no high-priority entries
- * yet shouldn't ship an empty skill).
- */
-function filterHighSignal(entries) {
-    const filtered = entries.filter((e) => {
-        const p = String(e.priority).toLowerCase();
-        return p === 'critical' || p === 'high';
-    });
-    return filtered.length > 0 ? filtered : [...entries];
-}
-/**
- * Render the body in tight, decision-driving form for the Claude Code
- * Skill format. Skills get loaded into Claude's prompt when the skill's
- * `description` matches the current task, so the body must be short and
- * directly actionable — no preamble, no metadata about generation, no
- * pipelines (Claude can run `shrk task` for those when needed).
- *
- * Sections:
- *   1. Where files belong (path conventions, top N) — most-leveraged signal.
- *   2. Rules to follow (Critical + High only) — pads context otherwise.
- *   3. Do / Don't — forbidden actions and verification commands.
- *   4. How to write code in this repo — the gen → review → apply loop
- *      verbatim, since Claude needs to know shrk is the write path.
- */
-function renderSkillBody(inspection, options) {
-    const { rules: allRules, paths: allPaths } = gatherRulesAndPaths(inspection, {
-        ...options,
-        // Pull more upfront, then filter down to high-signal — keeps the
-        // softcap-at-15 default but the inlined skill stays terse.
-        maxRules: options.maxRules ?? 24,
-        maxPaths: options.maxPaths ?? 18,
-    });
-    // Skills are inlined into the prompt — every entry costs Claude
-    // context. Only ship the items the user said are load-bearing.
-    const rules = filterHighSignal(allRules).slice(0, options.maxRules ?? 12);
-    const paths = filterHighSignal(allPaths).slice(0, options.maxPaths ?? 10);
-    const sections = [];
-    if (inspection.config?.description) {
-        sections.push(`## About this codebase\n\n${inspection.config.description}`);
-    }
-    const pathsBody = renderPathsSection(paths);
-    if (pathsBody) {
-        sections.push(`## Where files belong\n\nWhen creating or moving a file, place it according to these conventions:\n\n${pathsBody}`);
-    }
-    const rulesBody = renderRulesSection(rules);
-    if (rulesBody) {
-        sections.push(`## Rules this codebase follows\n\nApply these whenever you generate, modify, or review code:\n\n${rulesBody}`);
-    }
-    const agg = aggregateActionHints(inspection.knowledgeEntries);
-    const doDont = [];
-    if (agg.forbiddenActions.length) {
-        doDont.push('**Do not:**');
-        for (const f of agg.forbiddenActions.slice(0, 8))
-            doDont.push(`- ${f}`);
-        doDont.push('');
-    }
-    if (agg.verificationCommands.length) {
-        doDont.push('**Verify changes with:**');
-        for (const c of agg.verificationCommands.slice(0, 6))
-            doDont.push(`- \`${c}\``);
-    }
-    if (doDont.length) {
-        sections.push(`## Do / Don't\n\n${doDont.join('\n').trim()}`);
-    }
-    sections.push(`## How to write code in this repo\n\n` +
-        `This repository uses [SharkCraft](https://github.com/shrkcrft/sharkcraft) to gate writes — the CLI is the only write path, and writes go through a plan → review → apply loop.\n\n` +
-        `1. **Get a task packet** before non-trivial work: \`shrk task "<one-sentence task>"\` returns the focused rules, paths, templates, and verification commands for that task.\n` +
-        `2. **Scaffold via templates** instead of writing files freehand: \`shrk gen <template-id> <name> --dry-run --save-plan plan.json\` produces a signed plan.\n` +
-        `3. **Apply the plan** through the CLI: \`shrk apply plan.json --verify-signature\` — never write through MCP.\n` +
-        `4. **Check the result**: \`shrk check boundaries\` + the verification commands listed above.\n\n` +
-        `For ad-hoc questions about the codebase, query the MCP server (\`shrk mcp serve\`) or run \`shrk context --task "<query>"\` for token-budgeted context.`);
-    return sections.join('\n\n');
-}
-/**
- * Build the YAML frontmatter for a Claude Code Skill. The `description`
- * field is what Claude uses to decide whether to load this skill — keep
- * it specific (project name + what's covered) so it doesn't trigger on
- * unrelated tasks.
- */
-function renderSkillFrontmatter(inspection) {
-    const slug = projectSlug(inspection.config?.projectName);
-    const projectName = inspection.config?.projectName ?? slug;
-    const description = `Codebase rules, path conventions, and review gates for ${projectName}. ` +
-        `Use this skill whenever generating, modifying, or reviewing code in this repository — ` +
-        `it tells you the per-file path conventions, the architecture boundaries, the verification commands, ` +
-        `and the safe write path (CLI plan → review → apply).`;
-    return `---\nname: ${slug}\ndescription: ${JSON.stringify(description)}\n---`;
-}
 export function renderExport(inspection, options) {
-    const suggestedPath = defaultOutputFor(options.format, inspection);
+    const body = renderBody(inspection, options);
+    const suggestedPath = DEFAULT_OUTPUT_PATH[options.format];
     let content = '';
     switch (options.format) {
-        case 'agents-md': {
-            const body = renderBody(inspection, options);
+        case 'agents-md':
             content = `# Agents Guide\n\n${PREAMBLE}\n\n${body}\n`;
             break;
-        }
-        case 'claude-md': {
-            const body = renderBody(inspection, options);
+        case 'claude-md':
             content = `# CLAUDE.md\n\n${PREAMBLE}\n\nThis file is read by Claude Code (claude.ai/code) at session start. Treat it as a compatibility view of the project's SharkCraft knowledge — use the MCP server (\`shrk mcp serve\`) for the live, queryable source of truth.\n\n${body}\n`;
             break;
-        }
-        case 'claude-skill': {
-            // Claude Code Skill: YAML frontmatter declares when to load this,
-            // body is tight decision-driving content. No preamble, no boilerplate
-            // — every token in here costs Claude context when loaded.
-            const frontmatter = renderSkillFrontmatter(inspection);
-            const projectName = inspection.config?.projectName ?? 'this codebase';
-            const body = renderSkillBody(inspection, options);
-            content = `${frontmatter}\n\n# ${projectName} — codebase guide\n\n${body}\n`;
-            break;
-        }
         case 'cursor-rules':
             // Cursor MDC frontmatter: leave alwaysApply off so the user can tune.
-            content = `---\ndescription: SharkCraft project rules (auto-generated)\nalwaysApply: false\n---\n\n${PREAMBLE}\n\n${renderBody(inspection, options)}\n`;
+            content = `---\ndescription: SharkCraft project rules (auto-generated)\nalwaysApply: false\n---\n\n${PREAMBLE}\n\n${body}\n`;
             break;
         case 'copilot-instructions':
-            content = `# Copilot instructions\n\n${PREAMBLE}\n\n${renderBody(inspection, options)}\n`;
+            content = `# Copilot instructions\n\n${PREAMBLE}\n\n${body}\n`;
             break;
     }
     return { format: options.format, suggestedPath, content };
@@ -249,14 +124,12 @@ export function renderExport(inspection, options) {
 export function isExportFormat(value) {
     return (value === 'agents-md' ||
         value === 'claude-md' ||
-        value === 'claude-skill' ||
         value === 'cursor-rules' ||
         value === 'copilot-instructions');
 }
 export const ALL_EXPORT_FORMATS = Object.freeze([
     'agents-md',
     'claude-md',
-    'claude-skill',
     'cursor-rules',
     'copilot-instructions',
 ]);

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

@@ -1 +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;AAUD,eAAO,MAAM,UAAU,EAAE,SAAS,SAAS,EA2W1C,CAAC"}
+{"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"}

package/dist/init/init-templates.js

@@ -1,18 +1,9 @@
-// Self-contained scaffolding for `shrk init --legacy`. Every generated
-// `sharkcraft/*.ts` file must work in a brand-new downstream repo where
-// no `@shrkcrft/*` packages are installed beyond the CLI itself. The
-// loaders (knowledge / templates / pipelines / path-conventions) are
-// shape-agnostic — they accept any object with the required string
-// fields — so each emitted file declares its own minimal helpers +
-// enum-like constants inline.
 export const INIT_FILES = [
     {
         relativePath: 'sharkcraft.config.ts',
-        content: `// Generated by \`shrk init --legacy\`. Plain default export — no
-// @shrkcrft/* import required. The config loader validates this object
-// by shape (zod), so the literal works without a helper call.
+        content: `import { defineSharkCraftConfig } from '@shrkcrft/config';
 
-export default {
+export default defineSharkCraftConfig({
   projectName: 'my-project',
   description: 'A SharkCraft-powered repository.',
   knowledgeFiles: ['knowledge.ts'],
@@ -22,36 +13,12 @@ export default {
   docsFiles: ['docs/overview.md', 'docs/architecture.md', 'docs/quick-start.md'],
   defaultMaxTokens: 4000,
   defaultScope: ['typescript'],
-};
+});
 `,
     },
     {
         relativePath: 'knowledge.ts',
-        content: `// Local helpers — keep this file self-contained (no @shrkcrft/* imports).
-// The knowledge loader is shape-agnostic; it accepts any object whose
-// \`id\`, \`title\`, and \`content\` are strings.
-
-const KnowledgePriority = {
-  Critical: 'critical',
-  High: 'high',
-  Medium: 'medium',
-  Low: 'low',
-} as const;
-
-const KnowledgeType = {
-  Rule: 'rule',
-  Path: 'path',
-  Template: 'template',
-  Architecture: 'architecture',
-  Technical: 'technical',
-  Convention: 'convention',
-  Workflow: 'workflow',
-  Warning: 'warning',
-} as const;
-
-function defineKnowledgeEntry<T>(entry: T): T {
-  return entry;
-}
+        content: `import { defineKnowledgeEntry, KnowledgeType, KnowledgePriority } from '@shrkcrft/knowledge';
 
 export const projectOverview = defineKnowledgeEntry({
   id: 'project.overview',
@@ -100,20 +67,8 @@ export default [projectOverview, aiAgentBriefing, generationSafety];
     },
     {
         relativePath: 'rules.ts',
-        content: `// Local helpers — keep this file self-contained (no @shrkcrft/* imports).
-
-const KnowledgePriority = {
-  Critical: 'critical',
-  High: 'high',
-  Medium: 'medium',
-  Low: 'low',
-} as const;
-
-const KnowledgeType = { Rule: 'rule' } as const;
-
-function defineRule<T>(rule: T): T {
-  return { ...rule, type: KnowledgeType.Rule } as T;
-}
+        content: `import { defineRule } from '@shrkcrft/rules';
+import { KnowledgePriority } from '@shrkcrft/knowledge';
 
 export const tsNamingClasses = defineRule({
   id: 'typescript.naming.classes',
@@ -187,15 +142,81 @@ export default [
     },
     {
         relativePath: 'paths.ts',
-        content: PATHS_PLACEHOLDER_CONTENT(),
+        content: `import { definePathConvention } from '@shrkcrft/paths';
+import { KnowledgePriority } from '@shrkcrft/knowledge';
+
+export const appSrc = definePathConvention({
+  id: 'app.src',
+  title: 'Application source root',
+  path: 'src',
+  description: 'All application source lives here.',
+  priority: KnowledgePriority.Critical,
+  scope: ['typescript'],
+  tags: ['source-path', 'root'],
+  appliesWhen: ['generate-code'],
+});
+
+export const services = definePathConvention({
+  id: 'app.services',
+  title: 'Application services',
+  path: 'src/services',
+  description: 'Application services live here.',
+  priority: KnowledgePriority.High,
+  scope: ['typescript', 'backend'],
+  tags: ['service', 'source-path'],
+  appliesWhen: ['generate-service', 'create-business-logic'],
+});
+
+export const utils = definePathConvention({
+  id: 'app.utils',
+  title: 'Utilities',
+  path: 'src/utils',
+  description: 'Pure functions, no side effects.',
+  priority: KnowledgePriority.Medium,
+  scope: ['typescript'],
+  tags: ['util', 'source-path'],
+  appliesWhen: ['generate-utility'],
+});
+
+export const features = definePathConvention({
+  id: 'app.features',
+  title: 'Feature folders',
+  path: 'src/features',
+  description: 'Vertical feature slices. Use this for end-to-end features.',
+  priority: KnowledgePriority.Medium,
+  scope: ['typescript'],
+  tags: ['feature', 'source-path'],
+  appliesWhen: ['generate-feature'],
+});
+
+export const tests = definePathConvention({
+  id: 'app.tests',
+  title: 'Test files',
+  path: 'tests',
+  description: 'Test files (or co-located *.spec.ts next to the unit under test).',
+  priority: KnowledgePriority.Medium,
+  scope: ['typescript', 'testing'],
+  tags: ['test', 'source-path'],
+  appliesWhen: ['generate-test'],
+});
+
+export const docs = definePathConvention({
+  id: 'app.docs',
+  title: 'Documentation',
+  path: 'docs',
+  description: 'Long-form human-readable docs (optional).',
+  priority: KnowledgePriority.Low,
+  scope: ['typescript'],
+  tags: ['docs'],
+  appliesWhen: ['add-docs'],
+});
+
+export default [appSrc, services, utils, features, tests, docs];
+`,
     },
     {
         relativePath: 'templates.ts',
-        content: `// Local helpers — keep this file self-contained (no @shrkcrft/* imports).
-
-function defineTemplate<T>(template: T): T {
-  return template;
-}
+        content: `import { defineTemplate } from '@shrkcrft/templates';
 
 export const tsService = defineTemplate({
   id: 'typescript.service',
@@ -208,8 +229,8 @@ export const tsService = defineTemplate({
     { name: 'name', required: true, description: 'kebab-case file name (e.g. user-profile)' },
     { name: 'className', required: true, description: 'PascalCase class name (e.g. UserProfileService)' },
   ],
-  targetPath: ({ name }: { name: string }) => \`src/services/\${name}.service.ts\`,
-  content: ({ className }: { className: string }) => \`export class \${className} {
+  targetPath: ({ name }) => \`src/services/\${name}.service.ts\`,
+  content: ({ className }) => \`export class \${className} {
   constructor() {}
 
   init(): void {
@@ -232,14 +253,42 @@ export const tsUtility = defineTemplate({
     { name: 'name', required: true, description: 'kebab-case file name' },
     { name: 'camel', required: true, description: 'camelCase function name' },
   ],
-  targetPath: ({ name }: { name: string }) => \`src/utils/\${name}.ts\`,
-  content: ({ camel }: { camel: string }) => \`export function \${camel}(input: unknown): unknown {
+  targetPath: ({ name }) => \`src/utils/\${name}.ts\`,
+  content: ({ camel }) => \`export function \${camel}(input: unknown): unknown {
   return input;
 }
 \`,
   postGenerationNotes: ['Keep utilities pure. No side effects, no shared mutable state.'],
 });
 
+export const tsFeatureFolder = defineTemplate({
+  id: 'typescript.feature',
+  name: 'TypeScript Feature folder',
+  description: 'Creates a vertical feature slice (index + service + types).',
+  tags: ['typescript', 'feature'],
+  scope: ['typescript'],
+  appliesWhen: ['generate-feature'],
+  variables: [
+    { name: 'name', required: true },
+    { name: 'pascal', required: true },
+  ],
+  files: ({ name, pascal }) => [
+    {
+      targetPath: \`src/features/\${name}/index.ts\`,
+      content: \`export * from './\${name}.service.ts';\nexport * from './\${name}.types.ts';\n\`,
+    },
+    {
+      targetPath: \`src/features/\${name}/\${name}.service.ts\`,
+      content: \`import type { I\${pascal}Config } from './\${name}.types.ts';\n\nexport class \${pascal}Service {\n  constructor(private readonly config: I\${pascal}Config) {}\n}\n\`,
+    },
+    {
+      targetPath: \`src/features/\${name}/\${name}.types.ts\`,
+      content: \`export interface I\${pascal}Config {\n  enabled: boolean;\n}\n\`,
+    },
+  ],
+  postGenerationNotes: ['Add tests under tests/<feature> or co-located *.spec.ts.'],
+});
+
 export const tsTest = defineTemplate({
   id: 'typescript.test',
   name: 'TypeScript Test File',
@@ -251,18 +300,11 @@ export const tsTest = defineTemplate({
     { name: 'name', required: true },
     { name: 'pascal', required: true },
   ],
-  targetPath: ({ name }: { name: string }) => \`tests/\${name}.spec.ts\`,
-  content: ({ pascal }: { pascal: string }) => \`import { describe, expect, test } from 'bun:test';
-
-describe('\${pascal}', () => {
-  test('placeholder', () => {
-    expect(true).toBe(true);
-  });
-});
-\`,
+  targetPath: ({ name }) => \`tests/\${name}.spec.ts\`,
+  content: ({ pascal }) => \`import { describe, expect, test } from 'bun:test';\n\ndescribe('\${pascal}', () => {\n  test('placeholder', () => {\n    expect(true).toBe(true);\n  });\n});\n\`,
 });
 
-export default [tsService, tsUtility, tsTest];
+export default [tsService, tsUtility, tsFeatureFolder, tsTest];
 `,
     },
     {
@@ -369,65 +411,3 @@ Lower-priority work for SharkCraft-powered knowledge in this repo.
 `,
     },
 ];
-function PATHS_PLACEHOLDER_CONTENT() {
-    // The legacy seed ships generic path examples. The modern preset path
-    // (`shrk init --preset <id>`) is workspace-aware. To avoid emitting
-    // broken defaults like `src/services/` in repos that don't have them,
-    // the legacy seed now ships *commented* examples plus an `// TODO:`
-    // marker the human is expected to fill in. The runner-instructions in
-    // docs/onboarding.md describe how to derive paths from the live repo.
-    return `// Local helpers — keep this file self-contained (no @shrkcrft/* imports).
-
-const KnowledgePriority = {
-  Critical: 'critical',
-  High: 'high',
-  Medium: 'medium',
-  Low: 'low',
-} as const;
-
-const KnowledgeType = { Path: 'path' } as const;
-
-function definePathConvention<T>(convention: T): T {
-  return { ...convention, type: KnowledgeType.Path } as T;
-}
-
-// TODO: replace the examples below with real path conventions for this
-// repository. Run \`shrk onboard --dry-run\` to see what the inference
-// engine detects from the workspace.
-
-export const appSrc = definePathConvention({
-  id: 'app.src',
-  title: 'Application source root',
-  path: 'src',
-  description: 'All application source lives here. Adjust to match this repo.',
-  priority: KnowledgePriority.Critical,
-  scope: ['typescript'],
-  tags: ['source-path', 'root'],
-  appliesWhen: ['generate-code'],
-});
-
-export const tests = definePathConvention({
-  id: 'app.tests',
-  title: 'Test files',
-  path: 'tests',
-  description: 'Test files. Many repos co-locate \`*.spec.ts\` next to the unit under test instead — pick one.',
-  priority: KnowledgePriority.Medium,
-  scope: ['typescript', 'testing'],
-  tags: ['test', 'source-path'],
-  appliesWhen: ['generate-test'],
-});
-
-export const docs = definePathConvention({
-  id: 'app.docs',
-  title: 'Documentation',
-  path: 'docs',
-  description: 'Long-form human-readable docs (optional).',
-  priority: KnowledgePriority.Low,
-  scope: ['typescript'],
-  tags: ['docs'],
-  appliesWhen: ['add-docs'],
-});
-
-export default [appSrc, tests, docs];
-`;
-}

package/dist/main.d.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 import { CommandRegistry } from './command-registry.js';
 export declare function buildRegistry(): CommandRegistry;
 export declare function runCli(argv: readonly string[]): Promise<number>;

package/dist/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":";AACA,OAAO,EACL,eAAe,EAIhB,MAAM,uBAAuB,CAAC;AAyV/B,wBAAgB,aAAa,IAAI,eAAe,CA2V/C;AAED,wBAAsB,MAAM,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CA2BrE;AAkGD;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CA4CxE"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":";AACA,OAAO,EACL,eAAe,EAIhB,MAAM,uBAAuB,CAAC;AAqX/B,wBAAgB,aAAa,IAAI,eAAe,CA2V/C;AAED,wBAAsB,MAAM,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CA2BrE;AAqGD;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CA4CxE"}