peaks-cli 1.0.17 → 1.0.18

package/dist/src/services/scan/existing-system-service.js

@@ -0,0 +1,300 @@
+import { readdir, stat } from 'node:fs/promises';
+import { basename, join, relative } from 'node:path';
+import { isDirectory, pathExists, readText } from '../../shared/fs.js';
+import { scanArchetype } from './archetype-service.js';
+const DEFAULT_MAX_TOKENS = 40;
+const DEFAULT_SAMPLES = 5;
+const COLOR_KEYWORDS = ['color', 'primary', 'success', 'warning', 'error', 'danger', 'info', 'bg', 'background', 'border', 'text'];
+const SPACING_KEYWORDS = ['spacing', 'gap', 'padding', 'margin', 'size'];
+const TYPO_KEYWORDS = ['font', 'text-size', 'line-height', 'letter-spacing', 'heading'];
+const RADIUS_KEYWORDS = ['radius', 'rounded'];
+const STYLE_DIRS = ['src/styles', 'src/style', 'styles', 'src/assets/styles', 'src/theme', 'theme'];
+const COMPONENT_DIRS = ['src/components', 'src/Components', 'components'];
+const SERVICE_DIRS = ['src/services', 'src/service', 'src/api', 'src/apis'];
+const HOOK_DIRS = ['src/hooks', 'src/hook', 'src/composables'];
+function classifyToken(name) {
+    const lower = name.toLowerCase();
+    if (RADIUS_KEYWORDS.some((kw) => lower.includes(kw)))
+        return 'radius';
+    if (TYPO_KEYWORDS.some((kw) => lower.includes(kw)))
+        return 'typography';
+    if (SPACING_KEYWORDS.some((kw) => lower.includes(kw)))
+        return 'spacing';
+    if (COLOR_KEYWORDS.some((kw) => lower.includes(kw)))
+        return 'color';
+    return null;
+}
+function parseLessOrSassVars(content, sourceRel) {
+    const tokens = [];
+    // Match `@var: value;` (Less) or `$var: value;` (Sass)
+    const regex = /^\s*[@$]([a-zA-Z][\w-]*)\s*:\s*([^;]+);/gm;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        const [, rawName, rawValue] = match;
+        if (rawName === undefined || rawValue === undefined)
+            continue;
+        tokens.push({ name: rawName, value: rawValue.trim(), source: sourceRel });
+    }
+    return tokens;
+}
+function parseCssVars(content, sourceRel) {
+    const tokens = [];
+    const regex = /--([a-zA-Z][\w-]*)\s*:\s*([^;]+);/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        const [, rawName, rawValue] = match;
+        if (rawName === undefined || rawValue === undefined)
+            continue;
+        tokens.push({ name: `--${rawName}`, value: rawValue.trim(), source: sourceRel });
+    }
+    return tokens;
+}
+async function walkStyleFiles(projectRoot) {
+    const found = [];
+    for (const candidate of STYLE_DIRS) {
+        const full = join(projectRoot, candidate);
+        if (!(await isDirectory(full)))
+            continue;
+        const queue = [full];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (current === undefined)
+                break;
+            let entries;
+            try {
+                entries = await readdir(current, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                    continue;
+                const entryPath = join(current, entry.name);
+                if (entry.isDirectory()) {
+                    queue.push(entryPath);
+                }
+                else if (/\.(less|scss|sass|css)$/i.test(entry.name)) {
+                    found.push(entryPath);
+                }
+            }
+        }
+    }
+    return found;
+}
+async function extractTailwindTokens(projectRoot) {
+    const candidates = ['tailwind.config.js', 'tailwind.config.ts', 'tailwind.config.cjs', 'tailwind.config.mjs'];
+    for (const candidate of candidates) {
+        const full = join(projectRoot, candidate);
+        if (await pathExists(full)) {
+            const content = await readText(full);
+            const tokens = [];
+            // Heuristic: extract keys under theme.extend.* via simple regex.
+            const colorBlock = /colors\s*:\s*\{([\s\S]*?)\}/.exec(content);
+            if (colorBlock?.[1] !== undefined) {
+                const colorRegex = /([a-zA-Z_][\w-]*)\s*:\s*['"`]([^'"`]+)['"`]/g;
+                let match;
+                while ((match = colorRegex.exec(colorBlock[1])) !== null) {
+                    const [, name, value] = match;
+                    if (name !== undefined && value !== undefined) {
+                        tokens.push({ name, value, source: candidate });
+                    }
+                }
+            }
+            return { tokens, source: { path: candidate, kind: 'tailwind-config' } };
+        }
+    }
+    return { tokens: [], source: null };
+}
+async function listFilesByMtime(dir, exts, max) {
+    if (!(await isDirectory(dir)))
+        return [];
+    const collected = [];
+    const queue = [dir];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (current === undefined)
+            break;
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                continue;
+            const full = join(current, entry.name);
+            if (entry.isDirectory()) {
+                queue.push(full);
+            }
+            else if (exts.test(entry.name)) {
+                try {
+                    const stats = await stat(full);
+                    collected.push({ path: full, mtimeMs: stats.mtimeMs });
+                }
+                catch {
+                    // skip unreadable
+                }
+            }
+        }
+    }
+    collected.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return collected.slice(0, max);
+}
+function classifyComponentNaming(samples) {
+    if (samples.length === 0)
+        return 'unknown';
+    let pascal = 0;
+    let kebab = 0;
+    for (const sample of samples) {
+        const name = basename(sample.path).replace(/\.[^.]+$/, '');
+        if (/^[A-Z][a-zA-Z0-9]*$/.test(name))
+            pascal += 1;
+        else if (/^[a-z][a-z0-9-]*$/.test(name))
+            kebab += 1;
+    }
+    if (pascal > 0 && kebab === 0)
+        return 'PascalCase';
+    if (kebab > 0 && pascal === 0)
+        return 'kebab-case';
+    if (pascal > 0 || kebab > 0)
+        return 'mixed';
+    return 'unknown';
+}
+async function firstExistingDir(projectRoot, candidates) {
+    for (const candidate of candidates) {
+        if (await isDirectory(join(projectRoot, candidate))) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function dedupeTokens(tokens, max) {
+    const seen = new Set();
+    const out = [];
+    for (const token of tokens) {
+        const key = `${token.name}=${token.value}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(token);
+        if (out.length >= max)
+            break;
+    }
+    return out;
+}
+function findInconsistencies(tokens) {
+    const issues = [];
+    const byName = new Map();
+    for (const token of tokens) {
+        const set = byName.get(token.name) ?? new Set();
+        set.add(token.value);
+        byName.set(token.name, set);
+    }
+    for (const [name, values] of byName.entries()) {
+        if (values.size > 1) {
+            issues.push(`token "${name}" has ${values.size} different values across sources: ${[...values].join(' | ')}`);
+        }
+    }
+    return issues;
+}
+export async function scanExistingSystem(options) {
+    const { projectRoot } = options;
+    const maxTokens = options.maxTokens ?? DEFAULT_MAX_TOKENS;
+    const maxSamples = options.maxSamplesPerKind ?? DEFAULT_SAMPLES;
+    const archetypeReport = await scanArchetype({ projectRoot });
+    if (archetypeReport.archetype === 'greenfield' || archetypeReport.archetype === 'unknown') {
+        return {
+            archetype: archetypeReport.archetype,
+            scanned: false,
+            scanSkippedReason: `archetype=${archetypeReport.archetype} — extraction only runs on legacy projects`,
+            visualTokens: { colors: [], spacing: [], typography: [], radii: [], sources: [] },
+            conventions: { componentNaming: 'unknown', componentDir: null, serviceDir: null, hookDir: null, samples: [] },
+            inconsistencies: []
+        };
+    }
+    const sources = [];
+    const rawTokens = [];
+    const styleFiles = await walkStyleFiles(projectRoot);
+    for (const file of styleFiles) {
+        const content = await readText(file);
+        const rel = relative(projectRoot, file).split(/[\\/]/).join('/');
+        if (/\.less$/i.test(file)) {
+            const lessTokens = parseLessOrSassVars(content, rel);
+            if (lessTokens.length > 0) {
+                sources.push({ path: rel, kind: 'less-vars' });
+                rawTokens.push(...lessTokens);
+            }
+        }
+        else if (/\.s[ac]ss$/i.test(file)) {
+            const sassTokens = parseLessOrSassVars(content, rel);
+            if (sassTokens.length > 0) {
+                sources.push({ path: rel, kind: 'sass-vars' });
+                rawTokens.push(...sassTokens);
+            }
+        }
+        const cssVars = parseCssVars(content, rel);
+        if (cssVars.length > 0) {
+            sources.push({ path: rel, kind: 'css-vars' });
+            rawTokens.push(...cssVars);
+        }
+    }
+    const tailwind = await extractTailwindTokens(projectRoot);
+    if (tailwind.source !== null) {
+        sources.push(tailwind.source);
+        rawTokens.push(...tailwind.tokens);
+    }
+    const colors = [];
+    const spacing = [];
+    const typography = [];
+    const radii = [];
+    for (const token of rawTokens) {
+        const category = classifyToken(token.name);
+        if (category === 'color')
+            colors.push(token);
+        else if (category === 'spacing')
+            spacing.push(token);
+        else if (category === 'typography')
+            typography.push(token);
+        else if (category === 'radius')
+            radii.push(token);
+    }
+    const componentDir = await firstExistingDir(projectRoot, COMPONENT_DIRS);
+    const serviceDir = await firstExistingDir(projectRoot, SERVICE_DIRS);
+    const hookDir = await firstExistingDir(projectRoot, HOOK_DIRS);
+    const componentSamples = componentDir !== null
+        ? await listFilesByMtime(join(projectRoot, componentDir), /\.(tsx|jsx|vue|svelte)$/i, maxSamples)
+        : [];
+    const serviceSamples = serviceDir !== null
+        ? await listFilesByMtime(join(projectRoot, serviceDir), /\.(ts|js)$/i, maxSamples)
+        : [];
+    const hookSamples = hookDir !== null
+        ? await listFilesByMtime(join(projectRoot, hookDir), /\.(ts|js)$/i, maxSamples)
+        : [];
+    const samples = [
+        ...componentSamples.map((sample) => ({ path: relative(projectRoot, sample.path).split(/[\\/]/).join('/'), kind: 'component' })),
+        ...serviceSamples.map((sample) => ({ path: relative(projectRoot, sample.path).split(/[\\/]/).join('/'), kind: 'service' })),
+        ...hookSamples.map((sample) => ({ path: relative(projectRoot, sample.path).split(/[\\/]/).join('/'), kind: 'hook' }))
+    ];
+    return {
+        archetype: archetypeReport.archetype,
+        scanned: true,
+        visualTokens: {
+            colors: dedupeTokens(colors, maxTokens),
+            spacing: dedupeTokens(spacing, maxTokens),
+            typography: dedupeTokens(typography, maxTokens),
+            radii: dedupeTokens(radii, maxTokens),
+            sources
+        },
+        conventions: {
+            componentNaming: classifyComponentNaming(componentSamples),
+            componentDir,
+            serviceDir,
+            hookDir,
+            samples
+        },
+        inconsistencies: findInconsistencies(rawTokens)
+    };
+}

package/dist/src/services/scan/scan-types.d.ts

@@ -0,0 +1,59 @@
+export type ProjectArchetype = 'greenfield' | 'legacy-frontend' | 'legacy-fullstack' | 'frontend-monorepo' | 'unknown';
+export type ArchetypeSignal = {
+    name: string;
+    matched: boolean;
+    detail?: string;
+};
+export type ArchetypeReport = {
+    archetype: ProjectArchetype;
+    confidence: 'high' | 'medium' | 'low';
+    frontendOnly: boolean;
+    frontendOnlyReason: string;
+    signals: ArchetypeSignal[];
+    detected: {
+        hasPackageJson: boolean;
+        hasBackendFramework: boolean;
+        backendFrameworks: string[];
+        hasSwaggerOrProto: boolean;
+        swaggerPaths: string[];
+        hasMonorepoConfig: boolean;
+        monorepoConfigs: string[];
+        hasNextApiRoutes: boolean;
+        srcFileCount: number;
+        backendDirsPresent: string[];
+        lockfileAgeDays: number | null;
+    };
+};
+export type VisualTokenSource = {
+    path: string;
+    kind: 'less-vars' | 'sass-vars' | 'css-vars' | 'tailwind-config' | 'antd-config-provider' | 'theme-file';
+};
+export type VisualToken = {
+    name: string;
+    value: string;
+    source: string;
+};
+export type ConventionSample = {
+    path: string;
+    kind: 'component' | 'service' | 'hook' | 'page';
+};
+export type ExistingSystemReport = {
+    archetype: ProjectArchetype;
+    scanned: boolean;
+    scanSkippedReason?: string;
+    visualTokens: {
+        colors: VisualToken[];
+        spacing: VisualToken[];
+        typography: VisualToken[];
+        radii: VisualToken[];
+        sources: VisualTokenSource[];
+    };
+    conventions: {
+        componentNaming: 'PascalCase' | 'kebab-case' | 'mixed' | 'unknown';
+        componentDir: string | null;
+        serviceDir: string | null;
+        hookDir: string | null;
+        samples: ConventionSample[];
+    };
+    inconsistencies: string[];
+};

package/dist/src/services/scan/scan-types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/services/scan/type-sanity-service.d.ts

@@ -0,0 +1,23 @@
+import type { RequestType } from '../artifacts/artifact-prerequisites.js';
+export type FileCategory = 'source' | 'config' | 'docs' | 'lockfile' | 'test' | 'unknown';
+export type FileBreakdown = {
+    category: FileCategory;
+    count: number;
+    examples: string[];
+};
+export type TypeSanityReport = {
+    declaredType: RequestType;
+    gitAvailable: boolean;
+    changedFiles: string[];
+    breakdown: FileBreakdown[];
+    suggestedTypes: ReadonlyArray<RequestType>;
+    consistent: boolean;
+    rationale: string;
+};
+export type TypeSanityOptions = {
+    projectRoot: string;
+    declaredType: RequestType;
+    /** Compare working tree against this ref. Default 'HEAD' (covers staged + unstaged). */
+    baseRef?: string;
+};
+export declare function checkTypeSanity(options: TypeSanityOptions): TypeSanityReport;

package/dist/src/services/scan/type-sanity-service.js

@@ -0,0 +1,108 @@
+import { execFileSync } from 'node:child_process';
+import { extname, basename } from 'node:path';
+const SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.vue', '.svelte', '.py', '.go', '.rs', '.java', '.kt', '.swift', '.cpp', '.c', '.h', '.cs', '.rb', '.php', '.scala', '.dart', '.less', '.scss', '.sass', '.css']);
+const DOCS_EXTENSIONS = new Set(['.md', '.mdx', '.rst', '.txt']);
+const LOCKFILE_NAMES = new Set(['pnpm-lock.yaml', 'package-lock.json', 'yarn.lock', 'bun.lockb', 'Cargo.lock', 'Gemfile.lock', 'composer.lock', 'go.sum', 'poetry.lock']);
+const CONFIG_NAMES = new Set(['package.json', 'tsconfig.json', 'tsconfig.base.json', 'vite.config.ts', 'vite.config.js', 'webpack.config.js', 'next.config.js', 'next.config.ts', '.eslintrc', '.eslintrc.js', '.eslintrc.cjs', '.eslintrc.json', '.prettierrc', '.prettierrc.json', 'eslint.config.js', '.gitignore', '.npmrc', 'docker-compose.yml', 'docker-compose.yaml', 'Dockerfile', 'Makefile', '.editorconfig', 'tailwind.config.js', 'tailwind.config.ts', 'postcss.config.js', 'commitlint.config.js', 'lefthook.yml', 'turbo.json', 'lerna.json', 'pnpm-workspace.yaml', 'nx.json']);
+const CONFIG_EXTENSIONS = new Set(['.toml', '.ini', '.cfg', '.env']);
+function classifyFile(filePath) {
+    const name = basename(filePath);
+    const ext = extname(filePath).toLowerCase();
+    if (LOCKFILE_NAMES.has(name))
+        return 'lockfile';
+    if (CONFIG_NAMES.has(name))
+        return 'config';
+    if (CONFIG_EXTENSIONS.has(ext))
+        return 'config';
+    if (filePath.startsWith('.github/') || filePath.includes('/workflows/') || name === 'release.yml' || name.endsWith('.yml') || name.endsWith('.yaml'))
+        return 'config';
+    if (DOCS_EXTENSIONS.has(ext))
+        return 'docs';
+    // Test files: anything under tests/, __tests__/, or matching *.test.*, *.spec.*
+    if (/\b(?:tests?|__tests__|__mocks__|spec)\b/.test(filePath) || /\.(test|spec)\.[a-z]+$/i.test(name))
+        return 'test';
+    if (SOURCE_EXTENSIONS.has(ext))
+        return 'source';
+    return 'unknown';
+}
+function tryGitDiffFiles(projectRoot, baseRef) {
+    try {
+        // Combine: tracked changes vs baseRef + untracked files. Use porcelain status for untracked too.
+        const trackedRaw = execFileSync('git', ['-C', projectRoot, 'diff', '--name-only', baseRef], { encoding: 'utf8' });
+        const tracked = trackedRaw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+        const untrackedRaw = execFileSync('git', ['-C', projectRoot, 'ls-files', '--others', '--exclude-standard'], { encoding: 'utf8' });
+        const untracked = untrackedRaw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+        const merged = Array.from(new Set([...tracked, ...untracked]));
+        return { ok: true, files: merged };
+    }
+    catch {
+        return { ok: false, files: [] };
+    }
+}
+function buildBreakdown(files) {
+    const grouped = new Map();
+    for (const file of files) {
+        const category = classifyFile(file);
+        const list = grouped.get(category) ?? [];
+        list.push(file);
+        grouped.set(category, list);
+    }
+    return Array.from(grouped.entries()).map(([category, examples]) => ({
+        category,
+        count: examples.length,
+        examples: examples.slice(0, 5)
+    }));
+}
+function suggestTypes(breakdown) {
+    const counts = { source: 0, config: 0, docs: 0, lockfile: 0, test: 0, unknown: 0 };
+    for (const entry of breakdown)
+        counts[entry.category] = entry.count;
+    const hasSource = counts.source > 0;
+    const hasConfig = counts.config > 0;
+    const hasDocs = counts.docs > 0;
+    const hasLockfile = counts.lockfile > 0;
+    const hasTest = counts.test > 0;
+    if (!hasSource && !hasConfig && hasDocs)
+        return ['docs'];
+    if (!hasSource && !hasDocs && hasConfig)
+        return ['config'];
+    if (!hasSource && !hasDocs && !hasConfig && hasLockfile)
+        return ['chore'];
+    if (!hasSource && !hasDocs && !hasConfig && !hasLockfile && hasTest)
+        return ['bugfix', 'refactor'];
+    if (hasSource)
+        return ['feature', 'bugfix', 'refactor'];
+    return ['feature', 'bugfix', 'refactor', 'config', 'docs', 'chore'];
+}
+function isConsistent(declared, suggested) {
+    return suggested.includes(declared);
+}
+function buildRationale(declared, breakdown, suggested, consistent) {
+    const summary = breakdown.length === 0
+        ? 'no changed files detected'
+        : breakdown.map((entry) => `${entry.category}=${entry.count}`).join(', ');
+    if (consistent) {
+        return `declared --type=${declared} is consistent with the changed files (${summary})`;
+    }
+    return `declared --type=${declared} disagrees with the changed files (${summary}); suggested types: ${suggested.join(' | ')}`;
+}
+export function checkTypeSanity(options) {
+    const baseRef = options.baseRef ?? 'HEAD';
+    const { ok: gitAvailable, files } = tryGitDiffFiles(options.projectRoot, baseRef);
+    const breakdown = buildBreakdown(files);
+    const suggested = suggestTypes(breakdown);
+    const consistent = !gitAvailable ? true : files.length === 0 ? true : isConsistent(options.declaredType, suggested);
+    return {
+        declaredType: options.declaredType,
+        gitAvailable,
+        changedFiles: files,
+        breakdown,
+        suggestedTypes: suggested,
+        consistent,
+        rationale: !gitAvailable
+            ? 'git unavailable or not a git repository — type sanity check skipped (returns consistent=true)'
+            : files.length === 0
+                ? `no changes detected against ${baseRef} — type sanity check skipped (returns consistent=true)`
+                : buildRationale(options.declaredType, breakdown, suggested, consistent)
+    };
+}

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.18";

package/dist/src/shared/version.js

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

package/package.json

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