minimal-vibe-coding-kit 0.5.0 → 0.5.1

package/.claude/skills/tutien/scripts/command.mjs

@@ -13,6 +13,14 @@ const TONE_ALIASES = new Map([
   ['gentle', 'serene'],
   ['spicy', 'spirited']
 ]);
+const STORY_LANGUAGES = new Set(['auto', 'vi', 'en', 'zh']);
+const STORY_STYLES = new Set(['auto', 'classic-quest', 'web-serial', 'daily-life', 'clan-epic', 'comic-adventure']);
+const STORY_FOCUSES = new Set(['balanced', 'project', 'characters', 'world', 'sect-politics']);
+
+const allowedOr = (value, allowed, fallback) => allowed.has(String(value).toLowerCase()) ? String(value).toLowerCase() : fallback;
+export const normalizeStoryLanguage = (value) => allowedOr(value, STORY_LANGUAGES, 'auto');
+export const normalizeStoryStyle = (value) => allowedOr(value, STORY_STYLES, 'auto');
+export const normalizeStoryFocus = (value) => allowedOr(value, STORY_FOCUSES, 'balanced');
 
 export const TUTIEN_EXPERIENCE = Object.freeze({
   kind: 'wholesome-coding-classification-game',
@@ -48,15 +56,21 @@ export function parseInvocation(argsString = '') {
     score: 'hidden',
     includeExcerpts: false,
     range: 'all',
-    sources: []
+    sources: [],
+    story: 'on',
+    storyLanguage: 'auto',
+    storyStyle: 'auto',
+    storyFocus: 'balanced',
+    output: 'brief'
   };
+  const providedOptions = new Set();
   let action = null;
 
   // A direct request to end the experience always wins over report parsing.
   // This keeps prose mode and approval state from lingering after the user
   // asks to return to the kit's normal voice.
   if (isStopRequest(argsString)) {
-    return { action: 'off', isModeToggle: true, explicitAction: true, options };
+    return { action: 'off', isModeToggle: true, explicitAction: true, options, providedOptions: [] };
   }
 
   for (const tok of tokens) {
@@ -68,24 +82,29 @@ export function parseInvocation(argsString = '') {
     const key = tok.slice(0, eq);
     const value = tok.slice(eq + 1);
     switch (key) {
-      case 'language': options.language = value; break;
-      case 'tone': options.tone = normalizeTone(value); break;
-      case 'villains': options.villains = value === 'off' ? 'off' : 'on'; break;
-      case 'score': options.score = value === 'show' ? 'show' : 'hidden'; break;
-      case 'scope': options.scope = value; break;
-      case 'privacy': options.privacy = value; break;
-      case 'range': options.range = value; break;
-      case 'include-excerpts': options.includeExcerpts = value === 'true'; break;
-      case 'sources': options.sources = value.split(',').filter(Boolean); break;
-      case 'previous': options.previous = value; break;
-      case 'metric': options.metric = value; break;
-      case 'approve': options.approve = value; break;
-      case 'snapshot': options.snapshot = value === 'true'; break;
-      case 'faction': options.faction = value; break;
-      case 'affiliation': options.affiliation = value; break;
-      case 'paths': options.paths = value.split(',').filter(Boolean); break;
-      case 'domains': options.domains = value.split(',').filter(Boolean); break;
-      case 'authorization': options.authorization = value; break;
+      case 'language': providedOptions.add(key); options.language = value; break;
+      case 'tone': providedOptions.add(key); options.tone = normalizeTone(value); break;
+      case 'villains': providedOptions.add(key); options.villains = value === 'off' ? 'off' : 'on'; break;
+      case 'score': providedOptions.add(key); options.score = value === 'show' ? 'show' : 'hidden'; break;
+      case 'scope': providedOptions.add(key); options.scope = value; break;
+      case 'privacy': providedOptions.add(key); options.privacy = value; break;
+      case 'range': providedOptions.add(key); options.range = value; break;
+      case 'include-excerpts': providedOptions.add(key); options.includeExcerpts = value === 'true'; break;
+      case 'sources': providedOptions.add(key); options.sources = value.split(',').filter(Boolean); break;
+      case 'previous': providedOptions.add(key); options.previous = value; break;
+      case 'metric': providedOptions.add(key); options.metric = value; break;
+      case 'approve': providedOptions.add(key); options.approve = value; break;
+      case 'snapshot': providedOptions.add(key); options.snapshot = value === 'true'; break;
+      case 'faction': providedOptions.add(key); options.faction = value; break;
+      case 'affiliation': providedOptions.add(key); options.affiliation = value; break;
+      case 'paths': providedOptions.add(key); options.paths = value.split(',').filter(Boolean); break;
+      case 'domains': providedOptions.add(key); options.domains = value.split(',').filter(Boolean); break;
+      case 'authorization': providedOptions.add(key); options.authorization = value; break;
+      case 'story': providedOptions.add(key); options.story = value === 'off' ? 'off' : 'on'; break;
+      case 'story-language': providedOptions.add(key); options.storyLanguage = normalizeStoryLanguage(value); break;
+      case 'story-style': providedOptions.add(key); options.storyStyle = normalizeStoryStyle(value); break;
+      case 'story-focus': providedOptions.add(key); options.storyFocus = normalizeStoryFocus(value); break;
+      case 'output': providedOptions.add(key); options.output = value === 'ledger' ? 'ledger' : 'brief'; break;
       default: break;
     }
   }
@@ -96,7 +115,7 @@ export function parseInvocation(argsString = '') {
   const explicitAction = action !== null;
   if (!action) action = 'preview';
   const isModeToggle = action === 'on' || action === 'off' || action === 'status';
-  return { action, isModeToggle, explicitAction, options };
+  return { action, isModeToggle, explicitAction, options, providedOptions: [...providedOptions] };
 }
 
 // The livelier `spirited` voice is explicit opt-in. Safety-sensitive contexts

package/.claude/skills/tutien/scripts/project-profile.mjs

@@ -0,0 +1,202 @@
+// Read a deliberately small, known set of project manifests and reduce them
+// to safe metadata. Repo scripts are never executed and their bodies are never
+// returned or persisted.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+const MAX_METADATA_BYTES = 1024 * 1024;
+const MANIFESTS = Object.freeze([
+  'backbone.yml',
+  'package.json',
+  'yarn.lock',
+  'package-lock.json',
+  'pnpm-lock.yaml',
+  'bun.lock',
+  'bun.lockb',
+  'tsconfig.json',
+  'pyproject.toml',
+  'go.mod',
+  'Cargo.toml',
+  'pubspec.yaml',
+  'composer.json',
+  'pom.xml',
+  'build.gradle',
+  'build.gradle.kts'
+]);
+
+const STACK_RULES = Object.freeze([
+  ['react', ['react']],
+  ['typescript', ['typescript']],
+  ['vite', ['vite']],
+  ['material-ui', ['@mui/material', '@material-ui/core']],
+  ['nextjs', ['next']],
+  ['vue', ['vue']],
+  ['nuxt', ['nuxt']],
+  ['angular', ['@angular/core']],
+  ['svelte', ['svelte']],
+  ['tailwind-css', ['tailwindcss']],
+  ['express', ['express']],
+  ['nestjs', ['@nestjs/core']]
+]);
+
+const SAFE_SCRIPT = /^[A-Za-z0-9][A-Za-z0-9:_-]{0,63}$/;
+const VALIDATION_PRIORITY = ['validate', 'check', 'test', 'test:unit', 'lint', 'typecheck', 'build'];
+
+function regularFile(root, relative) {
+  const absolute = path.join(path.resolve(root), relative);
+  try {
+    const stat = fs.lstatSync(absolute);
+    if (!stat.isFile() || stat.isSymbolicLink()) return null;
+    return { path: relative, absolute, size: stat.size, mtimeMs: Math.trunc(stat.mtimeMs) };
+  } catch {
+    return null;
+  }
+}
+
+export function inventoryProjectMetadata(root) {
+  return MANIFESTS.map((name) => regularFile(root, name))
+    .filter(Boolean)
+    .map(({ path: relative, size, mtimeMs }) => ({ path: relative, size, mtimeMs }));
+}
+
+function readKnownFile(root, name, warnings) {
+  const item = regularFile(root, name);
+  if (!item) return null;
+  if (item.size > MAX_METADATA_BYTES) {
+    warnings.push({ code: 'metadata-too-large', path: name });
+    return null;
+  }
+  try {
+    return fs.readFileSync(item.absolute, 'utf8');
+  } catch {
+    warnings.push({ code: 'metadata-unreadable', path: name });
+    return null;
+  }
+}
+
+function safeSlug(value, fallback = null) {
+  const text = String(value ?? '').trim().toLowerCase();
+  return /^[a-z0-9][a-z0-9._-]{0,79}$/.test(text) ? text : fallback;
+}
+
+function yamlScalar(text, key) {
+  const match = text?.match(new RegExp(`^\\s*${key}:\\s*(.+)$`, 'm'));
+  if (!match) return null;
+  const value = match[1].trim().replace(/^['"]|['"]$/g, '');
+  return value.length <= 160 && !/[\r\n]/.test(value) ? value : null;
+}
+
+function packageManager(pkg, files) {
+  const declared = String(pkg?.packageManager ?? '').match(/^(npm|yarn|pnpm|bun)@/i)?.[1]?.toLowerCase();
+  if (declared) return declared;
+  if (files.has('pnpm-lock.yaml')) return 'pnpm';
+  if (files.has('yarn.lock')) return 'yarn';
+  if (files.has('bun.lock') || files.has('bun.lockb')) return 'bun';
+  return 'npm';
+}
+
+function scriptCommand(manager, key) {
+  if (manager === 'yarn') return `yarn ${key}`;
+  if (manager === 'pnpm') return `pnpm ${key}`;
+  if (manager === 'bun') return `bun run ${key}`;
+  return `npm run ${key}`;
+}
+
+function packageFacts(pkg, files) {
+  const deps = new Set([
+    ...Object.keys(pkg?.dependencies ?? {}),
+    ...Object.keys(pkg?.devDependencies ?? {}),
+    ...Object.keys(pkg?.peerDependencies ?? {})
+  ]);
+  const stack = STACK_RULES.filter(([, names]) => names.some((name) => deps.has(name))).map(([name]) => name);
+  if (files.has('tsconfig.json') && !stack.includes('typescript')) stack.push('typescript');
+
+  const manager = packageManager(pkg, files);
+  const scripts = Object.keys(pkg?.scripts ?? {}).filter((key) => SAFE_SCRIPT.test(key));
+  const validationCommands = VALIDATION_PRIORITY
+    .filter((key) => scripts.includes(key))
+    .slice(0, 3)
+    .map((key) => scriptCommand(manager, key));
+
+  const hasWebFramework = stack.some((name) => ['react', 'nextjs', 'vue', 'nuxt', 'angular', 'svelte'].includes(name));
+  const hasLibraryEntry = Boolean(pkg?.main || pkg?.module || pkg?.exports);
+  return {
+    projectId: safeSlug(pkg?.name),
+    packageManager: manager,
+    stack,
+    primaryLanguage: stack.includes('typescript') ? 'typescript' : 'javascript',
+    projectType: hasLibraryEntry ? 'library' : (hasWebFramework ? 'web-app' : 'node-project'),
+    validationCommands
+  };
+}
+
+function uniqueSlugs(values, limit = 16) {
+  return [...new Set(values.map((value) => safeSlug(value)).filter(Boolean))].slice(0, limit);
+}
+
+export function buildProjectProfile(root, options = {}) {
+  const resolvedRoot = path.resolve(root);
+  const inventory = inventoryProjectMetadata(resolvedRoot);
+  const files = new Set(inventory.map((item) => item.path));
+  const warnings = [];
+  const profile = {
+    projectId: safeSlug(path.basename(resolvedRoot), 'repo'),
+    description: null,
+    primaryLanguage: null,
+    projectType: null,
+    domains: [],
+    stack: [],
+    packageManager: null,
+    validationCommands: [],
+    recommendedValidation: null,
+    metadataSources: inventory.map((item) => item.path),
+    kitInstalled: files.has('backbone.yml') && fs.existsSync(path.join(resolvedRoot, '.vibekit', 'skills')),
+    authorization: options.authorization ?? null,
+    declared: { faction: options.faction, affiliation: options.affiliation, paths: options.paths },
+    warnings
+  };
+
+  const backbone = readKnownFile(resolvedRoot, 'backbone.yml', warnings);
+  if (backbone) {
+    profile.description = yamlScalar(backbone, 'description');
+    profile.primaryLanguage = safeSlug(yamlScalar(backbone, 'primary_language'));
+    profile.projectType = safeSlug(yamlScalar(backbone, 'type'));
+  }
+
+  const packageText = readKnownFile(resolvedRoot, 'package.json', warnings);
+  if (packageText) {
+    try {
+      const pkg = JSON.parse(packageText);
+      const facts = packageFacts(pkg, files);
+      Object.assign(profile, {
+        projectId: facts.projectId ?? profile.projectId,
+        packageManager: facts.packageManager,
+        stack: facts.stack,
+        primaryLanguage: profile.primaryLanguage ?? facts.primaryLanguage,
+        projectType: profile.projectType ?? facts.projectType,
+        validationCommands: facts.validationCommands
+      });
+    } catch {
+      warnings.push({ code: 'metadata-invalid-json', path: 'package.json' });
+    }
+  }
+
+  if (!profile.primaryLanguage) {
+    if (files.has('pyproject.toml')) profile.primaryLanguage = 'python';
+    else if (files.has('go.mod')) profile.primaryLanguage = 'go';
+    else if (files.has('Cargo.toml')) profile.primaryLanguage = 'rust';
+    else if (files.has('pubspec.yaml')) profile.primaryLanguage = 'dart';
+  }
+  if (!profile.projectType) profile.projectType = files.has('package.json') ? 'node-project' : 'software-project';
+
+  const domains = [...(options.domains ?? [])];
+  if (profile.stack.some((name) => ['react', 'nextjs', 'vue', 'nuxt', 'angular', 'svelte'].includes(name))) domains.push('frontend', 'application', 'interface');
+  if (profile.stack.includes('material-ui')) domains.push('ui', 'design', 'component');
+  if (profile.projectType === 'library') domains.push('library', 'framework');
+  profile.domains = uniqueSlugs(domains, 12);
+  profile.stack = uniqueSlugs(profile.stack, 12);
+  profile.recommendedValidation = profile.validationCommands[0] ?? null;
+  return profile;
+}
+