skiller 0.9.12 → 0.9.13

package/dist/core/PresetInstaller.js

@@ -42,6 +42,9 @@ const AgentSourceCompatibility_1 = require("./AgentSourceCompatibility");
 const ConfigLoader_1 = require("./ConfigLoader");
 const FileSystemUtils_1 = require("./FileSystemUtils");
 const project_paths_1 = require("./project-paths");
+const PRESET_CONFIG_RELATIVE_PATH = path
+    .join(project_paths_1.CANONICAL_SKILLER_DIR, 'preset.toml')
+    .replace(/\\/g, '/');
 const PRESET_MANIFEST_RELATIVE_PATH = path
     .join(project_paths_1.CANONICAL_SKILLER_DIR, '.skiller-preset-manifest.json')
     .replace(/\\/g, '/');
@@ -129,6 +132,13 @@ async function collectPresetFiles(rootDir) {
     await walk(rootDir);
     return results.sort((a, b) => a.localeCompare(b));
 }
+async function collectFileFromPath(targetPath) {
+    const stats = await fs_1.promises.stat(targetPath);
+    if (stats.isFile()) {
+        return targetPath;
+    }
+    throw new Error(`[skiller] Included path '${targetPath}' must resolve to a file, not a directory.`);
+}
 function isHardDenied(relativePath) {
     return HARD_DENY_PATTERNS.some((pattern) => (0, FileSystemUtils_1.matchesPattern)(relativePath, pattern));
 }
@@ -152,6 +162,40 @@ async function readRawTomlFile(filePath) {
         return {};
     }
 }
+async function readPresetConfig(presetRoot) {
+    const configPath = path.join(presetRoot, PRESET_CONFIG_RELATIVE_PATH);
+    const raw = await readRawTomlFile(configPath);
+    if (Object.keys(raw).length === 0) {
+        return { include: [] };
+    }
+    if (raw.version !== undefined && raw.version !== 1) {
+        throw new Error(`[skiller] ${PRESET_CONFIG_RELATIVE_PATH} in '${presetRoot}' must use version = 1.`);
+    }
+    if (raw.include !== undefined && !Array.isArray(raw.include)) {
+        throw new Error(`[skiller] ${PRESET_CONFIG_RELATIVE_PATH} in '${presetRoot}' must set include = ["path", ...].`);
+    }
+    return {
+        include: Array.isArray(raw.include)
+            ? raw.include.map((entry) => String(entry))
+            : [],
+    };
+}
+function deriveTargetRelativePath(sourcePath) {
+    const segments = normalizeRelativePath(path.resolve(sourcePath)).split('/');
+    const specialFileNames = new Set(['skills-lock.json', 'skiller-lock.json']);
+    for (let index = 0; index < segments.length; index += 1) {
+        const segment = segments[index];
+        if (segment === '.agents' ||
+            segment === '.claude' ||
+            segment === '.codex') {
+            return segments.slice(index).join('/');
+        }
+        if (specialFileNames.has(segment) && index === segments.length - 1) {
+            return segment;
+        }
+    }
+    return null;
+}
 async function looksLikePresetRoot(dirPath) {
     try {
         const stats = await fs_1.promises.stat(path.join(dirPath, '.agents'));
@@ -225,11 +269,10 @@ async function resolvePresetSourceInput(projectRoot, rawSource) {
     }
     return cwdCandidate;
 }
-async function writeMergedConfig(projectRoot, presetRoot) {
-    const baseConfigPath = path.join(presetRoot, project_paths_1.CANONICAL_SKILLER_DIR, project_paths_1.SKILLER_CONFIG_FILE);
+async function writeMergedConfig(projectRoot, baseConfigPath) {
     const localConfigPath = path.join(projectRoot, project_paths_1.CANONICAL_SKILLER_DIR, project_paths_1.SKILLER_CONFIG_FILE);
     const [baseRaw, localRaw] = await Promise.all([
-        readRawTomlFile(baseConfigPath),
+        baseConfigPath ? readRawTomlFile(baseConfigPath) : Promise.resolve({}),
         readRawTomlFile(localConfigPath),
     ]);
     const merged = (0, ConfigLoader_1.deepMergeConfig)((0, ConfigLoader_1.withoutSync)(baseRaw), (0, ConfigLoader_1.withoutSync)(localRaw));
@@ -244,21 +287,61 @@ async function installPresetIntoProject(projectRoot, options) {
     try {
         const { preset, presetRoot } = await resolvePresetRoot(workspace, options.preset);
         const previousManifest = await readPresetManifest(projectRoot);
-        const selectedFiles = (await collectPresetFiles(presetRoot)).filter((relativePath) => !isHardDenied(relativePath) &&
-            !COPY_EXCEPTIONS.has(relativePath) &&
+        const presetConfig = await readPresetConfig(presetRoot);
+        const nextSources = new Map();
+        let mergedConfigSourcePath;
+        for (const includePath of presetConfig.include) {
+            const resolvedIncludePath = path.resolve(presetRoot, includePath);
+            const sourcePath = await collectFileFromPath(resolvedIncludePath);
+            const targetRelativePath = deriveTargetRelativePath(sourcePath);
+            if (!targetRelativePath) {
+                throw new Error(`[skiller] Included path '${includePath}' in '${preset}/${PRESET_CONFIG_RELATIVE_PATH}' must resolve under .agents, .claude, .codex, skills-lock.json, or skiller-lock.json.`);
+            }
+            if (isHardDenied(targetRelativePath)) {
+                throw new Error(`[skiller] Included path '${includePath}' resolves to denied target '${targetRelativePath}'.`);
+            }
+            if (COPY_EXCEPTIONS.has(targetRelativePath)) {
+                mergedConfigSourcePath = sourcePath;
+                continue;
+            }
+            if (!isPresetAllowlisted(targetRelativePath)) {
+                throw new Error(`[skiller] Included path '${includePath}' resolves to unsupported target '${targetRelativePath}'.`);
+            }
+            nextSources.set(targetRelativePath, sourcePath);
+        }
+        const selectedFiles = (await collectPresetFiles(presetRoot)).filter((relativePath) => relativePath !== PRESET_CONFIG_RELATIVE_PATH &&
+            !isHardDenied(relativePath) &&
             isPresetAllowlisted(relativePath));
+        if (selectedFiles.includes(path
+            .join(project_paths_1.CANONICAL_SKILLER_DIR, project_paths_1.SKILLER_CONFIG_FILE)
+            .replace(/\\/g, '/'))) {
+            mergedConfigSourcePath = path.join(presetRoot, project_paths_1.CANONICAL_SKILLER_DIR, project_paths_1.SKILLER_CONFIG_FILE);
+        }
         const nextFiles = {};
         const synced = [];
+        for (const [targetRelativePath, sourcePath] of [
+            ...nextSources.entries(),
+        ].sort(([left], [right]) => left.localeCompare(right))) {
+            const content = await fs_1.promises.readFile(sourcePath);
+            const targetPath = path.join(projectRoot, targetRelativePath);
+            await fs_1.promises.mkdir(path.dirname(targetPath), { recursive: true });
+            await fs_1.promises.writeFile(targetPath, content);
+            nextFiles[targetRelativePath] = hashBuffer(content);
+            synced.push(targetRelativePath);
+        }
         for (const relativePath of selectedFiles) {
             const sourcePath = path.join(presetRoot, relativePath);
             const targetPath = path.join(projectRoot, relativePath);
+            if (COPY_EXCEPTIONS.has(relativePath)) {
+                continue;
+            }
             const content = await fs_1.promises.readFile(sourcePath);
             await fs_1.promises.mkdir(path.dirname(targetPath), { recursive: true });
             await fs_1.promises.writeFile(targetPath, content);
             nextFiles[relativePath] = hashBuffer(content);
             synced.push(relativePath);
         }
-        const mergedConfigHash = await writeMergedConfig(projectRoot, presetRoot);
+        const mergedConfigHash = await writeMergedConfig(projectRoot, mergedConfigSourcePath);
         nextFiles['.agents/skiller.toml'] = mergedConfigHash;
         synced.push('.agents/skiller.toml');
         const removed = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skiller",
-  "version": "0.9.12",
+  "version": "0.9.13",
   "description": "Skiller — apply the same rules to all coding agents",
   "main": "dist/lib.js",
   "publishConfig": {