peaks-cli 1.4.0 → 1.4.2

package/dist/src/cli/commands/skill-scope-commands.js

@@ -1,305 +0,0 @@
-/**
- * `peaks skill scope` CLI surface (slice 025.1).
- *
- * Four subcommands (mutually exclusive):
- * - `--detect` — dry-run; prints the relevance matrix, never touches files.
- * - `--apply`  — writes the source-of-truth + IDE-native config.
- * - `--show`   — reads the source-of-truth + native config back.
- * - `--reset`  — removes the source-of-truth + IDE-native config.
- *
- * Exit code matrix (tech-doc §6.3):
- *   0  success
- *   1  uncaught error
- *   2  invalid usage (missing/incompatible flags)
- *   3  source-of-truth written but adapter returned NOT_SUPPORTED
- *   4  adapter failure other than NOT_SUPPORTED
- */
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { detectSkillScope, } from '../../services/skill-scope/detect.js';
-import { resolveActiveAdapter, getScopeAdapter } from '../../services/skill-scope/registry.js';
-import { ideCompanionFilePath, readIdeCompanion, readSourceOfTruth, removeIfExists, scopeFilePath, writeSourceOfTruth, } from '../../services/skill-scope/source-of-truth.js';
-import { ALWAYS_RELEVANT_SKILLS } from '../../services/skill-scope/types.js';
-import { fail, getErrorMessage, ok } from '../../shared/result.js';
-import { addJsonOption, printResult } from '../cli-helpers.js';
-const VALID_ACTIONS = ['detect', 'apply', 'show', 'reset'];
-const VALID_IDES = ['claude-code', 'trae', 'codex', 'cursor', 'qoder', 'tongyi-lingma'];
-function isValidIde(value) {
-    return VALID_IDES.includes(value);
-}
-/**
- * G6: enforce the peaks-* allowlist. Re-adds any peak-* skill that is
- * missing from the allowlist, and removes any peak-* skill from the
- * denylist. The list is the same one declared in `types.ts`.
- */
-function enforcePeaksAllowlist(allowlist) {
-    const set = new Set(allowlist);
-    for (const name of ALWAYS_RELEVANT_SKILLS) {
-        if (name.startsWith('peaks-'))
-            set.add(name);
-    }
-    return [...set];
-}
-function stripPeaksFromDenylist(denylist) {
-    return denylist.filter((name) => !name.startsWith('peaks-'));
-}
-/**
- * Determine the IDE. Caller-supplied `--ide` wins; otherwise the registry
- * probes the project root.
- */
-async function resolveIde(projectRoot, override) {
-    if (override !== undefined) {
-        if (!isValidIde(override)) {
-            throw new Error(`Unknown IDE: ${override}. Valid: ${VALID_IDES.join(', ')}`);
-        }
-        return { ide: override, isFallback: false };
-    }
-    const resolved = await resolveActiveAdapter(projectRoot);
-    return { ide: resolved.adapter.ide, isFallback: resolved.isFallback };
-}
-/**
- * Stable timestamp (no millisecond jitter) for the `generatedAt` field.
- * `Date.now()` would still be deterministic per-run; we keep the natural
- * one to ensure `generatedAt` matches what the user sees on disk.
- */
-function nowIso() {
-    return new Date().toISOString();
-}
-/** Run the --detect subcommand. */
-async function runDetect(input) {
-    try {
-        const result = await detectSkillScope({ projectRoot: input.project });
-        const envelope = ok('skill.scope.detect', result);
-        const stdout = input.json === true ? JSON.stringify(envelope, null, 2) : JSON.stringify(result, null, 2);
-        return { exitCode: 0, envelope, stdout, stderr: '' };
-    }
-    catch (error) {
-        const envelope = fail('skill.scope.detect', 'DETECT_FAILED', getErrorMessage(error), null);
-        return { exitCode: 1, envelope, stdout: '', stderr: envelope.message ?? 'detect failed' };
-    }
-}
-/** Build the final ScopeConfig (applies G6 enforcement + override). */
-function buildScopeConfig(args) {
-    const strict = args.strict;
-    const detected = args.detected;
-    // Build allowlist from detected.relevant + (in loose) borderline.
-    const allowFromDetect = detected.skills
-        .filter((s) => s.relevance === 'relevant' || (!strict && s.relevance === 'borderline'))
-        .map((s) => s.name);
-    const merged = args.allowOverride !== undefined ? [...args.allowOverride, ...allowFromDetect] : allowFromDetect;
-    const enforced = enforcePeaksAllowlist(merged);
-    // Denylist: irrelevant skills (strict + loose both), minus anything in allowlist.
-    const denyFromDetect = detected.skills
-        .filter((s) => s.relevance === 'irrelevant' && !enforced.includes(s.name))
-        .map((s) => s.name);
-    const finalDeny = stripPeaksFromDenylist(denyFromDetect);
-    return {
-        generatedAt: nowIso(),
-        ide: args.ide,
-        strict,
-        allowlist: enforced,
-        denylist: finalDeny,
-        skills: detected.skills,
-        signals: detected.projectSignals,
-    };
-}
-/** Run the --apply subcommand. */
-async function runApply(input) {
-    // 1. Detect the scope.
-    const detected = await detectSkillScope({ projectRoot: input.project });
-    // --strict wins when both flags are passed. Default is --loose per PRD.
-    const isStrict = input.strict === true && input.loose !== true;
-    const loose = !isStrict;
-    const { ide, isFallback } = await resolveIde(input.project, input.ide);
-    const adapter = getScopeAdapter(ide);
-    const config = buildScopeConfig({
-        ide,
-        strict: isStrict,
-        detected,
-        ...(input.overrideAllowlist !== undefined ? { allowOverride: input.overrideAllowlist } : {}),
-    });
-    // 2. Write the source-of-truth first (atomic). Test seam: simulate failure.
-    let writtenFiles = [];
-    let sourceWritten = false;
-    try {
-        if (input.simulateSourceOfTruthWriteFailure) {
-            throw new Error('simulated source-of-truth write failure');
-        }
-        const file = await writeSourceOfTruth(input.project, config);
-        writtenFiles.push(file);
-        sourceWritten = true;
-    }
-    catch (error) {
-        const envelope = fail('skill.scope.apply', 'WRITE_FAILED', getErrorMessage(error), { ide, sourceWritten: false }, ['Fix filesystem permissions on the project root and retry']);
-        return { exitCode: 4, envelope, stdout: '', stderr: envelope.message ?? 'write failed' };
-    }
-    // 3. Call the adapter. Stub adapters return notSupported=true; we surface it.
-    const adapterInput = {
-        allowlist: config.allowlist,
-        denylist: config.denylist,
-        strict: config.strict,
-        projectRoot: input.project,
-        sourceConfig: config,
-        shadowFallback: input.shadowFallback === true,
-    };
-    let result;
-    try {
-        result = await adapter.applyScope(adapterInput);
-    }
-    catch (error) {
-        // Roll back the source-of-truth on adapter failure.
-        await removeIfExists(scopeFilePath(input.project));
-        const envelope = fail('skill.scope.apply', 'ADAPTER_FAILED', getErrorMessage(error), { ide, sourceWritten: false, writtenFiles: [] }, ['Inspect the adapter error and retry']);
-        return { exitCode: 4, envelope, stdout: '', stderr: envelope.message ?? 'adapter failed' };
-    }
-    // The stub adapter also writes the canonical skills.json — that's
-    // already on disk from step 2, so its second write is a no-op update.
-    const finalWrittenFiles = [...writtenFiles, ...result.writtenFiles];
-    const envelope = ok('skill.scope.apply', {
-        ide,
-        isFallback,
-        strict: isStrict,
-        loose,
-        allowlist: config.allowlist,
-        denylist: config.denylist,
-        signals: config.signals,
-        writtenFiles: finalWrittenFiles,
-        usedShadowStub: result.usedShadowStub,
-        notSupported: result.notSupported,
-        strippedFromDenylist: result.strippedFromDenylist ?? [],
-        error: result.error,
-    });
-    const stdout = input.json === true ? JSON.stringify(envelope, null, 2) : JSON.stringify(envelope.data, null, 2);
-    if (result.notSupported) {
-        // Stub adapter: NOT_SUPPORTED → exit 3, write error to stderr.
-        const stderr = `${result.error?.code ?? 'NOT_SUPPORTED'}: ${result.error?.message ?? 'not supported'}`;
-        return { exitCode: 3, envelope, stdout, stderr };
-    }
-    return { exitCode: 0, envelope, stdout, stderr: '' };
-}
-/** Run the --show subcommand. */
-async function runShow(input) {
-    const source = await readSourceOfTruth(input.project);
-    const { ide } = await resolveIde(input.project, input.ide);
-    const companionPath = ideCompanionFilePath(input.project, ide);
-    const companion = await readIdeCompanion(input.project, ide);
-    // For Claude Code, the native config is `.claude/settings.local.json`.
-    const nativeSettingsPath = join(input.project, '.claude', 'settings.local.json');
-    const nativeExists = existsSync(nativeSettingsPath);
-    let native = companion;
-    if (nativeExists) {
-        try {
-            const { readFile } = await import('node:fs/promises');
-            native = JSON.parse(await readFile(nativeSettingsPath, 'utf8'));
-        }
-        catch {
-            native = null;
-        }
-    }
-    const data = {
-        ide,
-        source,
-        native,
-        nativeSettingsPath: nativeExists ? '.claude/settings.local.json' : null,
-        companionPath: existsSync(companionPath) ? companionPath : null,
-    };
-    const envelope = ok('skill.scope.show', data);
-    const stdout = input.json === true ? JSON.stringify(envelope, null, 2) : JSON.stringify(data, null, 2);
-    return { exitCode: 0, envelope, stdout, stderr: '' };
-}
-/** Run the --reset subcommand. */
-async function runReset(input) {
-    const { ide } = await resolveIde(input.project, input.ide);
-    const adapter = getScopeAdapter(ide);
-    const resetResult = await adapter.resetScope({ projectRoot: input.project });
-    const sourceFile = scopeFilePath(input.project);
-    const sourceRemoved = await removeIfExists(sourceFile);
-    const allRemoved = [...resetResult.removedFiles, ...(sourceRemoved ? [sourceFile] : [])];
-    const envelope = ok('skill.scope.reset', {
-        ide,
-        removedFiles: allRemoved,
-    });
-    // Always include the canonical source-of-truth path in the human-readable
-    // summary, even if it didn't exist (so the user knows what was targeted).
-    const displayFiles = allRemoved.length > 0 ? allRemoved : [sourceFile, join(input.project, '.claude', 'settings.local.json')];
-    const summary = `removed: ${displayFiles.join(', ')}`;
-    const stdout = input.json === true ? JSON.stringify(envelope, null, 2) : summary;
-    return { exitCode: 0, envelope, stdout, stderr: '' };
-}
-/**
- * Programmatic entry point for `peaks skill scope`. Used by the CLI shim
- * AND by the unit tests.
- */
-export async function runSkillScopeCommand(input) {
-    if (!VALID_ACTIONS.includes(input.subcommand)) {
-        const envelope = fail('skill.scope', 'INVALID_USAGE', `Unknown action: ${input.subcommand}`, null);
-        return { exitCode: 2, envelope, stdout: '', stderr: envelope.message ?? 'invalid usage' };
-    }
-    switch (input.subcommand) {
-        case 'detect': return runDetect(input);
-        case 'apply': return runApply(input);
-        case 'show': return runShow(input);
-        case 'reset': return runReset(input);
-    }
-}
-/**
- * Register the `peaks skill scope` subcommand on the `skill` command group.
- * Mutually-exclusive flags: exactly one of --detect / --apply / --show / --reset.
- */
-export function registerSkillScopeCommands(program, io) {
-    // Find the existing 'skill' subcommand if any.
-    let skillCmd = program.commands.find((c) => c.name() === 'skill');
-    if (skillCmd === undefined) {
-        skillCmd = program.command('skill').description('Manage Peaks skills');
-    }
-    const scope = skillCmd
-        .command('scope')
-        .description('Per-project skill scoping: detect, apply, show, reset');
-    addJsonOption(scope
-        .option('--detect', 'dry-run: print the relevance matrix')
-        .option('--apply', 'apply the scope (writes source-of-truth + IDE config)')
-        .option('--show', 'show the currently applied scope')
-        .option('--reset', 'remove the scope config')
-        .option('--project <path>', 'target project root (defaults to cwd)', process.cwd())
-        .option('--strict', '--apply: only `relevant` skills in the allowlist')
-        .option('--loose', '--apply: `relevant` + `borderline` in the allowlist (default)')
-        .option('--ide <name>', 'force a specific IDE adapter (overrides auto-detect)')
-        .option('--shadow-fallback', '--apply: Claude Code uses shadow stubs for the denylist')).action(async (options) => {
-        const flags = [options.detect, options.apply, options.show, options.reset].filter(Boolean).length;
-        if (flags !== 1) {
-            const envelope = fail('skill.scope', 'INVALID_USAGE', 'Exactly one of --detect / --apply / --show / --reset is required', null, ['Pass exactly one action flag']);
-            printResult(io, envelope, options.json === true);
-            process.exitCode = 2;
-            return;
-        }
-        const subcommand = options.detect
-            ? 'detect'
-            : options.apply
-                ? 'apply'
-                : options.show
-                    ? 'show'
-                    : 'reset';
-        const result = await runSkillScopeCommand({
-            subcommand,
-            project: options.project ?? process.cwd(),
-            ...(options.strict !== undefined ? { strict: options.strict } : {}),
-            ...(options.loose !== undefined ? { loose: options.loose } : {}),
-            ...(options.ide !== undefined ? { ide: options.ide } : {}),
-            ...(options.shadowFallback !== undefined ? { shadowFallback: options.shadowFallback } : {}),
-            ...(options.json !== undefined ? { json: options.json } : {}),
-        });
-        if (options.json === true) {
-            if (result.envelope !== null)
-                printResult(io, result.envelope, true);
-        }
-        else {
-            if (result.stdout.length > 0)
-                io.stdout(result.stdout);
-            if (result.stderr.length > 0)
-                io.stderr(result.stderr);
-        }
-        if (result.exitCode !== 0) {
-            process.exitCode = result.exitCode;
-        }
-    });
-}

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

@@ -1,27 +0,0 @@
-declare const SHADCN_PACKAGE_NAME = "shadcn";
-declare const SHADCN_PACKAGE_VERSION = "4.7.0";
-declare const SHADCN_EXECUTABLE: string;
-export type ShadcnInvocationOptions = {
-    args: string[];
-    cwd?: string;
-};
-export type ShadcnInvocation = {
-    executable: typeof SHADCN_EXECUTABLE;
-    args: string[];
-    cwd: string;
-    packageName: typeof SHADCN_PACKAGE_NAME;
-    packageVersion: typeof SHADCN_PACKAGE_VERSION;
-};
-export type ShadcnExecutionResult = {
-    exitCode: number | null;
-    stdout: string;
-    stderr: string;
-};
-export type ShadcnProcessRunner = (invocation: ShadcnInvocation) => Promise<ShadcnExecutionResult>;
-declare function createShadcnEnvironment(sourceEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-export declare function createShadcnInvocation(options: ShadcnInvocationOptions): ShadcnInvocation;
-export declare function executeShadcnInvocation(invocation: ShadcnInvocation, runner?: ShadcnProcessRunner): Promise<ShadcnExecutionResult>;
-export declare const testInternals: {
-    createShadcnEnvironment: typeof createShadcnEnvironment;
-};
-export {};

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

@@ -1,128 +0,0 @@
-import { existsSync } from 'node:fs';
-import { spawn } from 'node:child_process';
-import { createRequire } from 'node:module';
-import { resolve } from 'node:path';
-const SHADCN_PACKAGE_NAME = 'shadcn';
-const SHADCN_PACKAGE_VERSION = '4.7.0';
-const SHADCN_EXECUTABLE = process.execPath;
-const SHADCN_BINARY_PATH = resolveShadcnBinaryPath();
-const SHADCN_PROCESS_TIMEOUT_MS = 600_000;
-const SHADCN_OUTPUT_LIMIT_BYTES = 10 * 1024 * 1024;
-const POSITIONAL_ARGUMENT_PREFIX = '-';
-const PRESERVED_ENV_KEYS = ['PATH', 'Path', 'HOME', 'USERPROFILE', 'APPDATA', 'LOCALAPPDATA', 'TEMP', 'TMP', 'SystemRoot', 'WINDIR'];
-function resolveShadcnBinaryPath() {
-    const require = createRequire(import.meta.url);
-    const binaryPath = require.resolve('shadcn');
-    if (!existsSync(binaryPath)) {
-        throw new Error('Unable to resolve local shadcn binary from shadcn');
-    }
-    return binaryPath;
-}
-function assertShadcnArgs(args) {
-    if (args.length === 0) {
-        throw new Error('shadcn arguments are required');
-    }
-    if (args[0]?.startsWith(POSITIONAL_ARGUMENT_PREFIX)) {
-        throw new Error('shadcn command must not start with -');
-    }
-}
-function createShadcnEnvironment(sourceEnv = process.env) {
-    const environment = {};
-    for (const key of PRESERVED_ENV_KEYS) {
-        const value = sourceEnv[key];
-        if (value !== undefined) {
-            environment[key] = value;
-        }
-    }
-    return environment;
-}
-function assertOutputLimit(currentSize, chunkSize) {
-    const nextSize = currentSize + chunkSize;
-    if (nextSize > SHADCN_OUTPUT_LIMIT_BYTES) {
-        throw new Error(`shadcn output exceeded ${SHADCN_OUTPUT_LIMIT_BYTES} bytes`);
-    }
-    return nextSize;
-}
-function terminateShadcnProcess(childProcess) {
-    if (childProcess.pid === undefined) {
-        childProcess.kill();
-        return;
-    }
-    if (process.platform === 'win32') {
-        const taskkillPath = process.env.SystemRoot ? resolve(process.env.SystemRoot, 'System32', 'taskkill.exe') : 'taskkill.exe';
-        spawn(taskkillPath, ['/pid', String(childProcess.pid), '/T', '/F'], { shell: false, stdio: 'ignore' });
-        return;
-    }
-    try {
-        process.kill(-childProcess.pid, 'SIGTERM');
-    }
-    catch {
-        childProcess.kill('SIGTERM');
-    }
-}
-function defaultShadcnProcessRunner(invocation) {
-    return new Promise((resolveResult, reject) => {
-        const childProcess = spawn(invocation.executable, invocation.args, {
-            cwd: invocation.cwd,
-            detached: process.platform !== 'win32',
-            env: createShadcnEnvironment(),
-            shell: false
-        });
-        const timeout = setTimeout(() => {
-            terminateShadcnProcess(childProcess);
-            reject(new Error(`shadcn process timed out after ${SHADCN_PROCESS_TIMEOUT_MS}ms`));
-        }, SHADCN_PROCESS_TIMEOUT_MS);
-        const stdoutChunks = [];
-        const stderrChunks = [];
-        let stdoutSize = 0;
-        let stderrSize = 0;
-        childProcess.stdout.on('data', (chunk) => {
-            try {
-                stdoutSize = assertOutputLimit(stdoutSize, chunk.length);
-                stdoutChunks.push(chunk);
-            }
-            catch (error) {
-                terminateShadcnProcess(childProcess);
-                reject(error);
-            }
-        });
-        childProcess.stderr.on('data', (chunk) => {
-            try {
-                stderrSize = assertOutputLimit(stderrSize, chunk.length);
-                stderrChunks.push(chunk);
-            }
-            catch (error) {
-                terminateShadcnProcess(childProcess);
-                reject(error);
-            }
-        });
-        childProcess.on('error', (error) => {
-            clearTimeout(timeout);
-            reject(error);
-        });
-        childProcess.on('close', (exitCode) => {
-            clearTimeout(timeout);
-            resolveResult({
-                exitCode,
-                stdout: Buffer.concat(stdoutChunks).toString('utf8'),
-                stderr: Buffer.concat(stderrChunks).toString('utf8')
-            });
-        });
-    });
-}
-export function createShadcnInvocation(options) {
-    assertShadcnArgs(options.args);
-    return {
-        executable: SHADCN_EXECUTABLE,
-        args: [SHADCN_BINARY_PATH, ...options.args],
-        cwd: options.cwd ?? process.cwd(),
-        packageName: SHADCN_PACKAGE_NAME,
-        packageVersion: SHADCN_PACKAGE_VERSION
-    };
-}
-export async function executeShadcnInvocation(invocation, runner = defaultShadcnProcessRunner) {
-    return runner(invocation);
-}
-export const testInternals = {
-    createShadcnEnvironment
-};

package/dist/src/services/skill-scope/adapters/_stub-helper.d.ts

@@ -1,39 +0,0 @@
-/**
- * Shared `makeStubAdapter` helper for the 5 non-shipped IDEs (Trae, Cursor,
- * Codex, Qoder, Tongyi Lingma).
- *
- * Each stub adapter:
- * 1. Implements `SkillScopeAdapter` with `supported: false`.
- * 2. In `applyScope`, ALWAYS writes the companion source-of-truth
- *    `.peaks/scope/<ide>-skills.json` first, then returns a NOT_SUPPORTED
- *    ApplyResult (the test contract asserts the source-of-truth is on disk
- *    even when the adapter can't apply it natively).
- * 3. In `showScope`, reads from the companion source-of-truth file.
- * 4. In `resetScope`, removes the companion source-of-truth file.
- * 5. In `detect`, returns 0.0 (the stub does not actually probe).
- *
- * The TODO comment in each stub file points at the follow-up slice (025.2+).
- */
-import type { SkillScopeAdapter } from '../types.js';
-/**
- * IDE-id -> companion source-of-truth shape. The companion file is a
- * parallel record so the user can see "this is what would have applied"
- * even when the IDE doesn't support a real implementation.
- */
-export interface StubSourceOfTruth {
-    readonly ide: string;
-    readonly generatedAt: string;
-    readonly strict: boolean;
-    readonly allowlist: readonly string[];
-    readonly denylist: readonly string[];
-    readonly todoRef: string;
-    readonly notes: string;
-}
-/**
- * The factory: every stub is a thin wrapper around this function. The
- * `applyScope` implementation ALWAYS writes the source-of-truth, then
- * returns a NOT_SUPPORTED ApplyResult (NOT a thrown error — the contract
- * for stub adapters is "return ok:false, notSupported:true" so the CLI
- * can keep going and surface the error to the user).
- */
-export declare function makeStubAdapter(ide: SkillScopeAdapter['ide'], todoRef: string, displayName: string): SkillScopeAdapter;

package/dist/src/services/skill-scope/adapters/_stub-helper.js

@@ -1,98 +0,0 @@
-/**
- * Shared `makeStubAdapter` helper for the 5 non-shipped IDEs (Trae, Cursor,
- * Codex, Qoder, Tongyi Lingma).
- *
- * Each stub adapter:
- * 1. Implements `SkillScopeAdapter` with `supported: false`.
- * 2. In `applyScope`, ALWAYS writes the companion source-of-truth
- *    `.peaks/scope/<ide>-skills.json` first, then returns a NOT_SUPPORTED
- *    ApplyResult (the test contract asserts the source-of-truth is on disk
- *    even when the adapter can't apply it natively).
- * 3. In `showScope`, reads from the companion source-of-truth file.
- * 4. In `resetScope`, removes the companion source-of-truth file.
- * 5. In `detect`, returns 0.0 (the stub does not actually probe).
- *
- * The TODO comment in each stub file points at the follow-up slice (025.2+).
- */
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { ideCompanionFilePath, removeIfExists, scopeFilePath, writeJsonAtomic } from '../source-of-truth.js';
-async function writeStubCompanion(ide, input, todoRef) {
-    const file = ideCompanionFilePath(input.projectRoot, ide);
-    const data = {
-        ide,
-        generatedAt: input.sourceConfig.generatedAt,
-        strict: input.strict,
-        allowlist: input.allowlist,
-        denylist: input.denylist,
-        todoRef,
-        notes: `Stub source-of-truth for ${ide}. The real config format has not yet been researched. ` +
-            `This file is written so the user's intent is captured and can be ported when ` +
-            `the follow-up slice (${todoRef}) lands.`,
-    };
-    await writeJsonAtomic(file, data);
-    return file;
-}
-async function readStubCompanion(ide, projectRoot) {
-    const file = ideCompanionFilePath(projectRoot, ide);
-    if (!existsSync(file))
-        return null;
-    try {
-        return JSON.parse(await readFile(file, 'utf8'));
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * The factory: every stub is a thin wrapper around this function. The
- * `applyScope` implementation ALWAYS writes the source-of-truth, then
- * returns a NOT_SUPPORTED ApplyResult (NOT a thrown error — the contract
- * for stub adapters is "return ok:false, notSupported:true" so the CLI
- * can keep going and surface the error to the user).
- */
-export function makeStubAdapter(ide, todoRef, displayName) {
-    const ideStr = String(ide);
-    return {
-        ide,
-        supported: false,
-        async detect() {
-            // Stubs never "win" detection; they return 0.0 so the registry falls
-            // back to the shipped adapter (Claude Code).
-            return 0.0;
-        },
-        async applyScope(input) {
-            // 1. Always write the source-of-truth first.
-            const companion = await writeStubCompanion(ideStr, input, todoRef);
-            // 2. Always write the canonical .peaks/scope/skills.json too.
-            const canonical = scopeFilePath(input.projectRoot);
-            await writeJsonAtomic(canonical, input.sourceConfig);
-            // 3. Surface NOT_SUPPORTED with a clear, IDE-named message.
-            const message = `${displayName} (${ideStr}) config format not yet researched — ${todoRef} follow-up. ` +
-                `Source-of-truth written to ${companion}.`;
-            return {
-                ide,
-                ok: false,
-                writtenFiles: [companion, canonical],
-                usedShadowStub: false,
-                notSupported: true,
-                error: { code: 'NOT_SUPPORTED', message },
-            };
-        },
-        async showScope(projectRoot) {
-            const native = await readStubCompanion(ideStr, projectRoot);
-            return { source: null, native, ide };
-        },
-        async resetScope(input) {
-            const removed = [];
-            const companion = ideCompanionFilePath(input.projectRoot, ideStr);
-            if (await removeIfExists(companion))
-                removed.push(companion);
-            // Also remove the canonical source-of-truth on reset.
-            const canonical = scopeFilePath(input.projectRoot);
-            if (await removeIfExists(canonical))
-                removed.push(canonical);
-            return { ide, removedFiles: removed };
-        },
-    };
-}

package/dist/src/services/skill-scope/adapters/claude-code.d.ts

@@ -1,59 +0,0 @@
-/**
- * `peaks skill scope` — Claude Code adapter (full impl, slice 025.1).
- *
- * Strategy (tech-doc-025 §3):
- * 1. PRIMARY: write `.claude/settings.local.json` with
- *    `permissions.allow: ["Skill(name)", ...]` + `permissions.deny: [...]`.
- * 2. FALLBACK (R1, `--shadow-fallback`): when the runtime probe determines
- *    Claude Code rejects `Skill(name)` in `permissions.deny`, write a
- *    shadow stub at `.claude/skills/<name>/SKILL.md` for each denylisted
- *    skill. Tagged with `_peaks_scope_disabled: true` (R6).
- *
- * Idempotency: dedupe the allow/deny arrays; shadow-stub writes skip
- * when the marker is already present. AC11.
- */
-import type { ApplyResult, ApplyScopeInput, ResetScopeInput, ResetScopeResult, ShowScopeResult, SkillScopeAdapter } from '../types.js';
-/** Format the `Skill(name)` string Claude Code's permission system uses. */
-export declare function skillRef(name: string): string;
-interface ClaudePermissions {
-    readonly allow: string[];
-    readonly deny: string[];
-}
-interface ClaudeSettings {
-    readonly permissions: ClaudePermissions;
-    readonly [key: string]: unknown;
-}
-/**
- * Map allowlist/denylist → permissions.allow/permissions.deny. Never sorts;
- * preserves input order. Always dedupes.
- */
-export declare function toPermissions(allowlist: readonly string[], denylist: readonly string[]): ClaudeSettings;
-/**
- * Strip any peaks-* name from the denylist (G6 hard constraint). Returns
- * the cleaned denylist + the list of stripped names for the audit log.
- */
-export declare function stripPeaksFromDenylist(denylist: readonly string[]): {
-    readonly cleaned: readonly string[];
-    readonly stripped: readonly string[];
-};
-/**
- * Runtime probe for whether Claude Code supports `Skill(name)` syntax in
- * `permissions.deny` (R1). For slice 025.1 we return `unknown` and let
- * the caller decide. Replace this with a real check when Claude Code's
- * `permissions.deny` schema is documented.
- */
-export declare function probeSkillDenySupport(): Promise<'support-allow-and-deny' | 'support-allow-only' | 'unknown'>;
-export declare class ClaudeCodeSkillScope implements SkillScopeAdapter {
-    readonly ide: "claude-code";
-    readonly supported = true;
-    constructor(_opts?: {
-        readonly projectRoot?: string;
-    });
-    /** detect(): returns 1.0 when the project root has a .claude/ dir. */
-    detect(projectRoot: string): Promise<number>;
-    applyScope(input: ApplyScopeInput): Promise<ApplyResult>;
-    showScope(projectRoot: string): Promise<ShowScopeResult>;
-    resetScope(input: ResetScopeInput): Promise<ResetScopeResult>;
-}
-export declare const CLAUDE_CODE_SKILL_SCOPE: SkillScopeAdapter;
-export {};