peaks-cli 1.0.17 → 1.0.19

package/dist/src/services/standards/project-context.js

@@ -0,0 +1,318 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+function readPackageJson(projectRoot) {
+    const pkgPath = join(projectRoot, 'package.json');
+    if (!existsSync(pkgPath))
+        return { exists: false, deps: {} };
+    try {
+        const raw = readFileSync(pkgPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        return {
+            exists: true,
+            deps: {
+                ...(parsed.dependencies ?? {}),
+                ...(parsed.devDependencies ?? {}),
+                ...(parsed.peerDependencies ?? {})
+            }
+        };
+    }
+    catch {
+        return { exists: true, deps: {} };
+    }
+}
+function configExists(projectRoot, candidates) {
+    for (const candidate of candidates) {
+        if (existsSync(join(projectRoot, candidate)))
+            return candidate;
+    }
+    return undefined;
+}
+function detectBuildTool(projectRoot) {
+    const map = [
+        ['umi', ['.umirc.ts', '.umirc.js', 'config/config.ts', 'config/config.js']],
+        ['next', ['next.config.js', 'next.config.ts', 'next.config.mjs']],
+        ['vite', ['vite.config.ts', 'vite.config.js', 'vite.config.mjs']],
+        ['rsbuild', ['rsbuild.config.ts', 'rsbuild.config.js']],
+        ['rspack', ['rspack.config.ts', 'rspack.config.js']],
+        ['farm', ['farm.config.ts', 'farm.config.js']],
+        ['craco', ['craco.config.js', 'craco.config.ts']],
+        ['webpack', ['webpack.config.js', 'webpack.config.ts']],
+        ['gulp', ['gulpfile.js', 'gulpfile.ts']],
+        ['angular', ['angular.json']]
+    ];
+    for (const [tool, candidates] of map) {
+        const found = configExists(projectRoot, candidates);
+        if (found !== undefined)
+            return { tool, path: found };
+    }
+    return { tool: 'unknown' };
+}
+function majorOf(version) {
+    if (version === undefined)
+        return undefined;
+    const cleaned = version.replace(/^[\^~>=<]+/, '').trim();
+    const major = cleaned.split('.')[0];
+    return major !== undefined && /^\d+$/.test(major) ? major : undefined;
+}
+function detectComponentLibrary(deps) {
+    if ('antd' in deps) {
+        const major = majorOf(deps['antd']);
+        const hasProSuite = '@ant-design/pro-components' in deps || Object.keys(deps).some((d) => d.startsWith('@ant-design/pro-'));
+        return hasProSuite
+            ? { name: 'antd-pro', ...(major !== undefined ? { majorVersion: major } : {}), hasProSuite: true }
+            : { name: 'antd', ...(major !== undefined ? { majorVersion: major } : {}) };
+    }
+    if ('@mui/material' in deps)
+        return { name: 'mui', ...(majorOf(deps['@mui/material']) !== undefined ? { majorVersion: majorOf(deps['@mui/material']) } : {}) };
+    if ('tailwindcss' in deps && Object.keys(deps).some((d) => d.startsWith('@radix-ui/')))
+        return { name: 'shadcn' };
+    if ('element-plus' in deps)
+        return { name: 'element-plus' };
+    if ('element-ui' in deps)
+        return { name: 'element-ui' };
+    if ('@arco-design/web-react' in deps)
+        return { name: 'arco' };
+    if ('tdesign-react' in deps || 'tdesign-vue-next' in deps)
+        return { name: 'tdesign' };
+    if ('@douyinfe/semi-ui' in deps)
+        return { name: 'semi' };
+    if ('@nextui-org/react' in deps)
+        return { name: 'nextui' };
+    if ('@chakra-ui/react' in deps)
+        return { name: 'chakra' };
+    if ('vant' in deps)
+        return { name: 'vant' };
+    return { name: 'none' };
+}
+function detectCssFrameworks(projectRoot, deps) {
+    const frameworks = [];
+    if ('tailwindcss' in deps || existsSync(join(projectRoot, 'tailwind.config.js')) || existsSync(join(projectRoot, 'tailwind.config.ts'))) {
+        frameworks.push('tailwind');
+    }
+    if ('less' in deps || 'less-loader' in deps)
+        frameworks.push('less');
+    if ('sass' in deps || 'node-sass' in deps || 'sass-loader' in deps)
+        frameworks.push('sass');
+    if ('styled-components' in deps)
+        frameworks.push('styled-components');
+    if ('@emotion/react' in deps || '@emotion/styled' in deps)
+        frameworks.push('emotion');
+    // css-modules detection is heuristic (Umi/Next default); skip unless we see *.module.* in src
+    return frameworks;
+}
+function detectCssConflicts(library, frameworks) {
+    const conflicts = [];
+    const hasTailwind = frameworks.includes('tailwind');
+    if (hasTailwind && (library.name === 'antd' || library.name === 'antd-pro')) {
+        conflicts.push("Tailwind preflight reset can break antd component base styles; set `corePlugins.preflight: false` in tailwind.config or scope Tailwind via `important: '#root'`.");
+    }
+    if (hasTailwind && library.name === 'mui') {
+        conflicts.push('Tailwind preflight overrides MUI base styles; disable Tailwind preflight or scope it away from MUI roots.');
+    }
+    const cssInJsCount = [frameworks.includes('styled-components'), frameworks.includes('emotion')].filter(Boolean).length;
+    if (cssInJsCount >= 2) {
+        conflicts.push('Multiple CSS-in-JS libraries detected (styled-components + emotion); pick one and remove the other.');
+    }
+    return conflicts;
+}
+function detectStateManagement(deps) {
+    const map = [
+        ['zustand', 'zustand'],
+        ['jotai', 'jotai'],
+        ['@reduxjs/toolkit', 'Redux Toolkit'],
+        ['redux', 'redux'],
+        ['valtio', 'valtio'],
+        ['mobx', 'mobx'],
+        ['hox', 'hox']
+    ];
+    return map.filter(([dep]) => dep in deps).map(([, label]) => label);
+}
+function detectRouting(deps) {
+    const out = [];
+    if ('react-router-dom' in deps)
+        out.push('react-router-dom');
+    if ('@umijs/max' in deps || '@umijs/preset-react' in deps)
+        out.push('Umi router');
+    if ('next' in deps)
+        out.push('Next.js file-based');
+    if ('vue-router' in deps)
+        out.push('vue-router');
+    return out;
+}
+function detectDataFetching(deps) {
+    const out = [];
+    if ('@tanstack/react-query' in deps)
+        out.push('@tanstack/react-query');
+    if ('swr' in deps)
+        out.push('swr');
+    if ('ahooks' in deps)
+        out.push('ahooks (useRequest)');
+    if ('umi-request' in deps)
+        out.push('umi-request');
+    if ('axios' in deps)
+        out.push('axios');
+    return out;
+}
+function detectLegacySignals(projectRoot, deps) {
+    const signals = [];
+    if ('moment' in deps)
+        signals.push('`moment` in deps — prefer `dayjs` or `date-fns` for new code');
+    if (Object.keys(deps).some((d) => d.startsWith('enzyme')))
+        signals.push('Enzyme test suite — write new tests with React Testing Library');
+    if ('redux-saga' in deps)
+        signals.push('redux-saga — keep saga patterns for existing flows; use Redux Toolkit thunks/RTK Query for new code');
+    if ('redux-thunk' in deps && !('@reduxjs/toolkit' in deps))
+        signals.push('Plain redux-thunk — prefer Redux Toolkit createAsyncThunk for new code');
+    if ('jquery' in deps)
+        signals.push('jQuery — do not add new jQuery usage');
+    if ('backbone' in deps)
+        signals.push('Backbone — legacy; do not add new Backbone code');
+    if (deps['vue']?.startsWith('2') === true)
+        signals.push('Vue 2 — preserve Options API for existing components');
+    // Lightweight heuristic for class components and inline styles in src/
+    const srcRoot = join(projectRoot, 'src');
+    if (existsSync(srcRoot)) {
+        const sample = sampleSourceFiles(srcRoot, 80);
+        let classComponentHits = 0;
+        let inlineStyleHits = 0;
+        for (const filePath of sample) {
+            try {
+                const content = readFileSync(filePath, 'utf8');
+                if (/extends\s+(?:React\.)?Component\b/.test(content))
+                    classComponentHits += 1;
+                const matches = content.match(/style=\{\{/g);
+                if (matches !== null)
+                    inlineStyleHits += matches.length;
+            }
+            catch {
+                // ignore unreadable files
+            }
+        }
+        if (classComponentHits >= 1)
+            signals.push(`React class components detected (${classComponentHits}+ files) — keep class style for existing modules, use function components + hooks for new code`);
+        if (inlineStyleHits >= 50)
+            signals.push(`Inline styles dominant (${inlineStyleHits}+ occurrences) — match existing styling for new code in same modules`);
+    }
+    return signals;
+}
+function sampleSourceFiles(root, limit) {
+    const out = [];
+    const queue = [root];
+    while (queue.length > 0 && out.length < limit) {
+        const dir = queue.shift();
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.startsWith('.') || entry === 'node_modules' || entry === 'dist' || entry === 'build')
+                continue;
+            const full = join(dir, entry);
+            let s;
+            try {
+                s = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (s.isDirectory()) {
+                queue.push(full);
+            }
+            else if (/\.(tsx|jsx)$/.test(entry)) {
+                out.push(full);
+                if (out.length >= limit)
+                    break;
+            }
+        }
+    }
+    return out;
+}
+function notableDepsList(deps) {
+    const interesting = ['monaco-editor', '@monaco-editor/react', 'react-querybuilder', '@dnd-kit/core', 'react-dnd', 'echarts', 'recharts', '@ant-design/charts', 'antd-style', 'lodash', 'lodash-es', 'rxjs', 'socket.io-client'];
+    return interesting.filter((d) => d in deps);
+}
+export function detectProjectContext(projectRoot) {
+    const { exists, deps } = readPackageJson(projectRoot);
+    const { tool, path } = detectBuildTool(projectRoot);
+    const componentLibrary = detectComponentLibrary(deps);
+    const cssFrameworks = detectCssFrameworks(projectRoot, deps);
+    return {
+        hasPackageJson: exists,
+        buildTool: tool,
+        ...(path !== undefined ? { buildConfigPath: path } : {}),
+        componentLibrary,
+        cssFrameworks,
+        cssConflicts: detectCssConflicts(componentLibrary, cssFrameworks),
+        stateManagement: detectStateManagement(deps),
+        routing: detectRouting(deps),
+        dataFetching: detectDataFetching(deps),
+        legacySignals: detectLegacySignals(projectRoot, deps),
+        notableDeps: notableDepsList(deps)
+    };
+}
+export function buildToolLabel(tool) {
+    const labels = {
+        umi: 'Umi',
+        next: 'Next.js',
+        vite: 'Vite',
+        rsbuild: 'Rsbuild',
+        rspack: 'Rspack',
+        farm: 'Farm',
+        craco: 'CRA + craco',
+        webpack: 'Webpack',
+        gulp: 'Gulp (legacy)',
+        angular: 'Angular',
+        custom: 'Custom build pipeline',
+        unknown: 'unknown'
+    };
+    return labels[tool];
+}
+export function componentLibraryLabel(lib) {
+    const base = (() => {
+        switch (lib.name) {
+            case 'antd':
+                return 'Ant Design';
+            case 'antd-pro':
+                return 'Ant Design + Ant Design Pro';
+            case 'mui':
+                return 'Material UI';
+            case 'shadcn':
+                return 'shadcn/ui (Tailwind + Radix)';
+            case 'element-plus':
+                return 'Element Plus';
+            case 'element-ui':
+                return 'Element UI';
+            case 'arco':
+                return 'Arco Design';
+            case 'tdesign':
+                return 'TDesign';
+            case 'semi':
+                return 'Semi Design';
+            case 'nextui':
+                return 'NextUI';
+            case 'chakra':
+                return 'Chakra UI';
+            case 'vant':
+                return 'Vant (mobile)';
+            case 'none':
+                return 'no component library detected';
+        }
+    })();
+    return lib.majorVersion !== undefined ? `${base} v${lib.majorVersion}` : base;
+}
+export function cssFrameworkLabel(framework) {
+    const labels = {
+        less: 'Less',
+        sass: 'Sass/SCSS',
+        tailwind: 'TailwindCSS',
+        'css-modules': 'CSS Modules',
+        'styled-components': 'styled-components',
+        emotion: 'Emotion',
+        'plain-css': 'plain CSS',
+        unknown: 'unknown'
+    };
+    return labels[framework];
+}

package/dist/src/services/standards/project-standards-service.js

@@ -1,5 +1,6 @@
 import { closeSync, constants, existsSync, lstatSync, mkdirSync, openSync, realpathSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { buildToolLabel, componentLibraryLabel, cssFrameworkLabel, detectProjectContext } from './project-context.js';
 const SOURCE = {
     sourceId: 'everything-claude-code',
     url: 'https://github.com/affaan-m/everything-claude-code',
@@ -82,8 +83,40 @@ function renderHeader(title) {
         ''
     ].join('\n');
 }
-function renderClaudeMd(language) {
-    return [
+function renderProjectStackSection(ctx) {
+    if (!ctx.hasPackageJson)
+        return '';
+    const lines = ['## Detected project stack', ''];
+    lines.push(`- Build tool: ${buildToolLabel(ctx.buildTool)}${ctx.buildConfigPath !== undefined ? ` (\`${ctx.buildConfigPath}\`)` : ''}`);
+    lines.push(`- Component library: ${componentLibraryLabel(ctx.componentLibrary)}`);
+    if (ctx.cssFrameworks.length > 0) {
+        lines.push(`- CSS: ${ctx.cssFrameworks.map(cssFrameworkLabel).join(', ')}`);
+    }
+    if (ctx.stateManagement.length > 0)
+        lines.push(`- State management: ${ctx.stateManagement.join(', ')}`);
+    if (ctx.routing.length > 0)
+        lines.push(`- Routing: ${ctx.routing.join(', ')}`);
+    if (ctx.dataFetching.length > 0)
+        lines.push(`- Data fetching: ${ctx.dataFetching.join(', ')}`);
+    if (ctx.notableDeps.length > 0)
+        lines.push(`- Notable deps: ${ctx.notableDeps.join(', ')}`);
+    lines.push('');
+    if (ctx.cssConflicts.length > 0) {
+        lines.push('## CSS framework conflicts', '');
+        for (const conflict of ctx.cssConflicts)
+            lines.push(`- ${conflict}`);
+        lines.push('');
+    }
+    if (ctx.legacySignals.length > 0) {
+        lines.push('## Legacy constraints (preserve for new code in the same modules)', '');
+        for (const signal of ctx.legacySignals)
+            lines.push(`- ${signal}`);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function renderClaudeMd(language, ctx) {
+    const head = [
         '# Project Instructions',
         '',
         '> 🤖 AI 生成，请审阅',
@@ -104,39 +137,109 @@ function renderClaudeMd(language) {
         'External reference: https://github.com/affaan-m/everything-claude-code is used as a curated reference only. Do not execute or install external content without explicit approval.',
         ''
     ].join('\n');
+    const stack = renderProjectStackSection(ctx);
+    return stack === '' ? head : `${head}\n${stack}`;
+}
+function renderCommonCodingStyle(ctx) {
+    const baseRules = [
+        '- Prefer simple, readable code over clever abstractions.',
+        '- Keep functions focused and files cohesive.',
+        '- Use immutable updates unless a language-specific convention explicitly favors mutation.',
+        '- Validate user input, external data, file paths, and configuration at system boundaries.',
+        '- Preserve existing project conventions when they are stricter than this baseline.'
+    ];
+    const stackRules = [];
+    const lib = ctx.componentLibrary.name;
+    if (lib === 'antd' || lib === 'antd-pro') {
+        const major = ctx.componentLibrary.majorVersion ?? '5';
+        stackRules.push(`- Use existing antd v${major} components (\`Button\`, \`Form\`, \`Table\`, \`Modal\`, \`Select\`). Never mix antd v3/v4/v5 APIs.`);
+        stackRules.push(`- Customize antd via \`theme.token\` / \`ConfigProvider\` / \`className\` / \`styles\`. Do NOT apply TailwindCSS utility classes directly to antd components.`);
+        if (ctx.componentLibrary.hasProSuite === true) {
+            stackRules.push('- Use `@ant-design/pro-components` (`ProTable`, `ProForm`, `ProLayout`) where the page is already pro-based — do not introduce a parallel non-pro table/form.');
+        }
+    }
+    if (lib === 'mui')
+        stackRules.push('- Style MUI via `sx`, `styled()`, and `theme`. Do NOT apply TailwindCSS utility classes directly to MUI components.');
+    if (lib === 'shadcn')
+        stackRules.push('- Use existing shadcn component variants and Tailwind utility classes. Do not introduce a competing component library.');
+    if (ctx.cssFrameworks.includes('tailwind') && (lib === 'antd' || lib === 'antd-pro' || lib === 'mui')) {
+        stackRules.push('- TailwindCSS is for layout/utility only; component-library tokens own component styling.');
+    }
+    if (ctx.cssFrameworks.includes('less'))
+        stackRules.push('- Less variables in `src/theme/*.less` (or equivalent) are the canonical design tokens — extend them, do not hardcode colors/spacing.');
+    if (ctx.stateManagement.length > 0)
+        stackRules.push(`- Follow the existing state library (${ctx.stateManagement.join(', ')}); do not introduce a competing state library.`);
+    if (ctx.dataFetching.length > 0)
+        stackRules.push(`- Reuse the existing data-fetching pattern (${ctx.dataFetching.join(', ')}) for new API calls.`);
+    for (const signal of ctx.legacySignals)
+        stackRules.push(`- ${signal}`);
+    const rules = stackRules.length > 0 ? [...baseRules, '', '## Project-specific rules', ...stackRules] : baseRules;
+    return `${renderHeader('Common Coding Standards')}${rules.join('\n')}\n`;
+}
+function renderCodeReview(ctx) {
+    const baseRules = [
+        '- Review diffs for correctness, maintainability, test coverage, and regression risk.',
+        '- Treat missing tests for changed behavior as a blocker unless the change is documentation-only.',
+        '- Verify code paths that handle filesystem, external APIs, credentials, user input, or generated artifacts.',
+        '- peaks-qa must use this guidance as part of code workflow preflight and final verification.'
+    ];
+    const extra = [];
+    const lib = ctx.componentLibrary.name;
+    if (lib === 'antd' || lib === 'antd-pro') {
+        extra.push('- Block PRs that introduce a second component library (MUI/shadcn/Chakra) alongside antd.');
+        extra.push('- Block PRs that import antd v3/v4 APIs in this v5 project, or vice versa.');
+    }
+    if (ctx.cssFrameworks.includes('tailwind') && (lib === 'antd' || lib === 'antd-pro' || lib === 'mui')) {
+        extra.push('- Flag Tailwind utility classes applied directly to component-library primitives; require component-library APIs instead.');
+    }
+    if (ctx.legacySignals.length > 0) {
+        extra.push('- Verify new code in legacy modules preserves the existing patterns (see `.claude/rules/common/coding-style.md` "Project-specific rules").');
+    }
+    const rules = extra.length > 0 ? [...baseRules, '', '## Project-specific review focus', ...extra] : baseRules;
+    return `${renderHeader('Code Review Standards')}${rules.join('\n')}\n`;
+}
+function renderSecurity(ctx) {
+    const baseRules = [
+        '- Never hardcode secrets, API keys, passwords, tokens, or credentials.',
+        '- Do not send private code or secrets to external services without explicit user authorization.',
+        '- Guard filesystem writes against path traversal, symlink, and junction escapes.',
+        '- Require explicit confirmation for destructive actions, external state changes, and credential use.'
+    ];
+    const extra = [];
+    if (ctx.buildTool === 'next')
+        extra.push('- Validate request body / query / params at every API route boundary (`pages/api/**` or `app/api/**`).');
+    if (ctx.dataFetching.length > 0)
+        extra.push(`- Sanitize and validate API responses before rendering or persisting (current fetchers: ${ctx.dataFetching.join(', ')}).`);
+    if (ctx.notableDeps.includes('monaco-editor') || ctx.notableDeps.includes('@monaco-editor/react')) {
+        extra.push('- Monaco editor content is untrusted; never `eval` or `Function`-construct user-authored code without an explicit, reviewed sandbox.');
+    }
+    const rules = extra.length > 0 ? [...baseRules, '', '## Project-specific security focus', ...extra] : baseRules;
+    return `${renderHeader('Security Review Standards')}${rules.join('\n')}\n`;
 }
-function renderCommonCodingStyle() {
-    return `${renderHeader('Common Coding Standards')}- Prefer simple, readable code over clever abstractions.
-- Keep functions focused and files cohesive.
-- Use immutable updates unless a language-specific convention explicitly favors mutation.
-- Validate user input, external data, file paths, and configuration at system boundaries.
-- Preserve existing project conventions when they are stricter than this baseline.
-`;
-}
-function renderCodeReview() {
-    return `${renderHeader('Code Review Standards')}- Review diffs for correctness, maintainability, test coverage, and regression risk.
-- Treat missing tests for changed behavior as a blocker unless the change is documentation-only.
-- Verify code paths that handle filesystem, external APIs, credentials, user input, or generated artifacts.
-- peaks-qa must use this guidance as part of code workflow preflight and final verification.
-`;
-}
-function renderSecurity() {
-    return `${renderHeader('Security Review Standards')}- Never hardcode secrets, API keys, passwords, tokens, or credentials.
-- Do not send private code or secrets to external services without explicit user authorization.
-- Guard filesystem writes against path traversal, symlink, and junction escapes.
-- Require explicit confirmation for destructive actions, external state changes, and credential use.
-`;
-}
-function renderLanguageCodingStyle(language) {
+function renderLanguageCodingStyle(language, ctx) {
     const languageName = language === 'generic' ? 'Generic' : language[0].toUpperCase() + language.slice(1);
     const typeSafetyRule = language === 'typescript' || language === 'javascript'
         ? '- Do not add new `any` types; use explicit domain types, generics, or `unknown` with narrowing.\n'
         : '';
-    return `${renderHeader(`${languageName} Coding Standards`)}- Apply project-local conventions before generic ${language} guidance.
-- Keep public APIs typed or documented according to ${language} ecosystem norms.
-${typeSafetyRule}- Prefer standard tooling and existing project scripts for formatting, linting, tests, and coverage.
-- peaks-rd must check this file before planning code changes in ${language} projects.
-`;
+    const baseRules = [
+        `- Apply project-local conventions before generic ${language} guidance.`,
+        `- Keep public APIs typed or documented according to ${language} ecosystem norms.`,
+        typeSafetyRule.trim() !== '' ? typeSafetyRule.trim() : null,
+        '- Prefer standard tooling and existing project scripts for formatting, linting, tests, and coverage.',
+        `- peaks-rd must check this file before planning code changes in ${language} projects.`
+    ].filter((line) => line !== null);
+    const extra = [];
+    if ((language === 'typescript' || language === 'javascript') && (ctx.componentLibrary.name === 'antd' || ctx.componentLibrary.name === 'antd-pro')) {
+        extra.push('- Type form values, table records, and API responses with named interfaces; do not rely on `Form.useForm()` inference for shared shapes.');
+    }
+    if ((language === 'typescript' || language === 'javascript') && ctx.dataFetching.includes('@tanstack/react-query')) {
+        extra.push('- Declare query/mutation generics (`useQuery<TData, TError>`) so consumers get typed data.');
+    }
+    if ((language === 'typescript' || language === 'javascript') && ctx.buildTool === 'umi') {
+        extra.push('- Use the project\'s existing service-layer pattern (`src/services/**`) for API calls; do not hand-roll `fetch` in components.');
+    }
+    const rules = extra.length > 0 ? [...baseRules, '', '## Project-specific rules', ...extra] : baseRules;
+    return `${renderHeader(`${languageName} Coding Standards`)}${rules.join('\n')}\n`;
 }
 function renderManagedClaudeMdIndex(language) {
     return [
@@ -189,19 +292,19 @@ function writeMissingStandardsRules(plan, writes = getPendingStandardsRuleWrites
     }
     return writtenFiles;
 }
-function createTemplates(language) {
+function createTemplates(language, ctx) {
     return [
-        { relativePath: 'CLAUDE.md', content: renderClaudeMd(language) },
-        { relativePath: '.claude/rules/common/code-review.md', content: renderCodeReview() },
-        { relativePath: '.claude/rules/common/coding-style.md', content: renderCommonCodingStyle() },
-        { relativePath: '.claude/rules/common/security.md', content: renderSecurity() },
-        { relativePath: `.claude/rules/${language}/coding-style.md`, content: renderLanguageCodingStyle(language) }
+        { relativePath: 'CLAUDE.md', content: renderClaudeMd(language, ctx) },
+        { relativePath: '.claude/rules/common/code-review.md', content: renderCodeReview(ctx) },
+        { relativePath: '.claude/rules/common/coding-style.md', content: renderCommonCodingStyle(ctx) },
+        { relativePath: '.claude/rules/common/security.md', content: renderSecurity(ctx) },
+        { relativePath: `.claude/rules/${language}/coding-style.md`, content: renderLanguageCodingStyle(language, ctx) }
     ];
 }
 function createManagedClaudeBlock(language) {
     return renderManagedClaudeMdIndex(language);
 }
-function buildClaudeUpdate(projectRoot, language) {
+function buildClaudeUpdate(projectRoot, language, ctx) {
     const filePath = resolve(projectRoot, 'CLAUDE.md');
     assertSafeClaudeMdPath(filePath, projectRoot);
     const existingContent = readFileIfExists(filePath);
@@ -211,7 +314,7 @@ function buildClaudeUpdate(projectRoot, language) {
             relativePath: 'CLAUDE.md',
             filePath,
             status: 'planned',
-            content: `${renderClaudeMd(language).trimEnd()}\n\n${managedBlock}`,
+            content: `${renderClaudeMd(language, ctx).trimEnd()}\n\n${managedBlock}`,
             appendBlock: '',
             reviewSuggestions: []
         };
@@ -281,7 +384,8 @@ export function createProjectStandardsInitPlan(options) {
     const projectRoot = normalizeRoot(options.projectRoot);
     assertSafeStandardsRoot(projectRoot);
     const language = options.language === undefined ? detectLanguage(projectRoot) : parseLanguage(options.language);
-    const plannedWrites = createTemplates(language).map((template) => buildWrite(projectRoot, template));
+    const ctx = detectProjectContext(projectRoot);
+    const plannedWrites = createTemplates(language, ctx).map((template) => buildWrite(projectRoot, template));
     return {
         apply: options.apply ?? false,
         projectRoot,
@@ -293,7 +397,8 @@ export function createProjectStandardsInitPlan(options) {
 }
 export function createProjectStandardsUpdatePlan(options) {
     const basePlan = createProjectStandardsInitPlan(options);
-    const claudeMd = buildClaudeUpdate(basePlan.projectRoot, basePlan.language);
+    const ctx = detectProjectContext(basePlan.projectRoot);
+    const claudeMd = buildClaudeUpdate(basePlan.projectRoot, basePlan.language, ctx);
     return {
         ...basePlan,
         claudeMd

package/dist/src/services/workspace/workspace-service.d.ts

@@ -0,0 +1,16 @@
+export type WorkspaceInitOptions = {
+    projectRoot: string;
+    sessionId: string;
+};
+export type WorkspaceInitReport = {
+    sessionId: string;
+    sessionRoot: string;
+    created: string[];
+    alreadyExisted: string[];
+};
+export declare class InvalidSessionIdError extends Error {
+    readonly code = "INVALID_SESSION_ID";
+    constructor(message: string);
+}
+export declare function validateSessionId(sessionId: string): void;
+export declare function initWorkspace(options: WorkspaceInitOptions): Promise<WorkspaceInitReport>;

package/dist/src/services/workspace/workspace-service.js

@@ -0,0 +1,66 @@
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { isDirectory } from '../../shared/fs.js';
+const SUBDIRECTORIES = [
+    'prd/source',
+    'prd/requests',
+    'ui/requests',
+    'rd/requests',
+    'qa/test-cases',
+    'qa/test-reports',
+    'qa/requests',
+    'sc',
+    'txt',
+    'system'
+];
+const SESSION_ID_PATTERN = /^\d{4}-\d{2}-\d{2}-[a-z][a-z0-9-]*[a-z0-9]$/;
+const PROHIBITED_SUFFIXES = ['session', 'work', 'task', 'test', 'temp', 'tmp'];
+export class InvalidSessionIdError extends Error {
+    code = 'INVALID_SESSION_ID';
+    constructor(message) {
+        super(message);
+        this.name = 'InvalidSessionIdError';
+    }
+}
+export function validateSessionId(sessionId) {
+    if (/^\d+$/.test(sessionId)) {
+        throw new InvalidSessionIdError(`Session id "${sessionId}" is numeric-only. Use the format YYYY-MM-DD-<kebab-slug> with a 2-5 word topic description.`);
+    }
+    if (/^\d{8}T\d{6}$/.test(sessionId) || /^\d{8}$/.test(sessionId)) {
+        throw new InvalidSessionIdError(`Session id "${sessionId}" looks like a bare timestamp. Use YYYY-MM-DD-<kebab-slug>.`);
+    }
+    if (/^\d{4}-\d{2}-\d{2}$/.test(sessionId)) {
+        throw new InvalidSessionIdError(`Session id "${sessionId}" is a bare date. Append a 2-5 word topic slug (e.g. "${sessionId}-add-user-auth").`);
+    }
+    if (!SESSION_ID_PATTERN.test(sessionId)) {
+        throw new InvalidSessionIdError(`Session id "${sessionId}" must match YYYY-MM-DD-<kebab-slug>, all lowercase, dashes only.`);
+    }
+    const suffix = sessionId.slice(11); // strip "YYYY-MM-DD-"
+    if (PROHIBITED_SUFFIXES.includes(suffix)) {
+        throw new InvalidSessionIdError(`Session id suffix "${suffix}" is a generic placeholder. Use a real topic slug (e.g. "add-user-auth", "v3-indicator-model").`);
+    }
+}
+export async function initWorkspace(options) {
+    validateSessionId(options.sessionId);
+    const sessionRoot = join(options.projectRoot, '.peaks', options.sessionId);
+    const created = [];
+    const alreadyExisted = [];
+    if (await isDirectory(sessionRoot)) {
+        alreadyExisted.push('.');
+    }
+    else {
+        await mkdir(sessionRoot, { recursive: true });
+        created.push('.');
+    }
+    for (const sub of SUBDIRECTORIES) {
+        const full = join(sessionRoot, sub);
+        if (await isDirectory(full)) {
+            alreadyExisted.push(sub);
+        }
+        else {
+            await mkdir(full, { recursive: true });
+            created.push(sub);
+        }
+    }
+    return { sessionId: options.sessionId, sessionRoot, created, alreadyExisted };
+}

package/dist/src/shared/version.d.ts

@@ -1 +1 @@
-export declare const CLI_VERSION = "1.0.17";
+export declare const CLI_VERSION = "1.0.19";

package/dist/src/shared/version.js

@@ -1 +1 @@
-export const CLI_VERSION = "1.0.17";
+export const CLI_VERSION = "1.0.19";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peaks-cli",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "Peaks CLI and short skill family for Claude Code automation.",
   "author": "SquabbyZ",
   "license": "MIT",