@fission-ai/openspec 1.14.2 → 1.15.0

package/dist/commands/workflow/status.js

@@ -3,7 +3,6 @@
  *
  * Displays artifact completion status for a change.
  */
-import ora from 'ora';
 import chalk from 'chalk';
 import { getChangeDir } from '../../core/planning-home.js';
 import { resolveRootForCommand, toPlanningHome, toRootOutput, withStoreFlag, isStoreSelectedRoot, findDeclaringProjectRoot, } from '../../core/root-selection.js';
@@ -33,7 +32,11 @@ export async function statusCommand(options) {
     if (!root) {
         return;
     }
-    const spinner = options.json ? undefined : ora('Loading change status...').start();
+    let spinner;
+    if (!options.json) {
+        const { default: ora } = await import('ora');
+        spinner = ora('Loading change status...').start();
+    }
     try {
         const planningHome = toPlanningHome(root);
         const projectRoot = root.path;

package/dist/commands/workflow/templates.js

@@ -3,7 +3,6 @@
  *
  * Shows resolved template paths for all artifacts in a schema.
  */
-import ora from 'ora';
 import path from 'path';
 import { resolveSchema, getSchemaDir, ArtifactGraph, } from '../../core/artifact-graph/index.js';
 import { FileSystemUtils } from '../../utils/file-system.js';
@@ -12,7 +11,11 @@ import { validateSchemaExists, DEFAULT_SCHEMA } from './shared.js';
 // Command Implementation
 // -----------------------------------------------------------------------------
 export async function templatesCommand(options) {
-    const spinner = options.json ? undefined : ora('Loading templates...').start();
+    let spinner;
+    if (!options.json) {
+        const { default: ora } = await import('ora');
+        spinner = ora('Loading templates...').start();
+    }
     try {
         const projectRoot = process.cwd();
         const schemaName = validateSchemaExists(options.schema ?? DEFAULT_SCHEMA, projectRoot);

package/dist/core/artifact-graph/outputs.js

@@ -1,12 +1,29 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import fg from 'fast-glob';
+import { expand } from 'brace-expansion';
+import picomatch from 'picomatch';
+import * as globby from 'tinyglobby';
 import { FileSystemUtils } from '../../utils/file-system.js';
 const EXTGLOB_RE = /[!*+?@]\([^(]*\)/u;
 const BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./u;
-// braces <=3.0.3 (fast-glob > micromatch) has no depth guard (GHSA-vfj7-8cjw-p6xm),
-// so reject nesting no real artifact pattern needs before it reaches the parser.
+const DUPLICATE_SLASH_RE = /(?!^)\/{2,}/gu;
+// Deeply nested braces can overflow a recursive expander. Reject nesting no real
+// artifact pattern needs before brace-expansion or tinyglobby see the pattern.
 const MAX_BRACE_NESTING = 16;
+// Nesting depth alone does not bound the work: `{a,b}` repeated 20 times is
+// only one level deep and expands to 1,048,576 patterns, which exhausts the
+// heap. fast-glob never expanded that far because micromatch compiled the
+// braces to a regex. No real artifact pattern needs more than a few hundred.
+const MAX_BRACE_EXPANSIONS = 1024;
+const ARTIFACT_GLOB_OPTIONS = {
+    absolute: true,
+    // Braces are expanded first so `{draft}` left behind stays a literal name.
+    braceExpansion: false,
+    // fast-glob migration: directory patterns must not grow a trailing `/**`.
+    expandDirectories: false,
+    followSymbolicLinks: true,
+    onlyFiles: true,
+};
 function assertBraceNesting(pattern) {
     // Mirror the braces parser: `[...]` and quoted runs are literal, `(` nests like
     // `{`, and a closer only closes the innermost group of its own kind.
@@ -39,6 +56,166 @@ function assertBraceNesting(pattern) {
         }
     }
 }
+function isDynamicSegment(segment) {
+    return segment.includes('*') || segment.includes('?') || segment.includes('[')
+        || EXTGLOB_RE.test(segment);
+}
+/**
+ * Static directory prefix of an expanded pattern, equivalent to the `base`
+ * fast-glob's generateTasks used to reject `../` before walking.
+ */
+function globBase(pattern) {
+    const segments = pattern.split('/');
+    if (segments.length <= 1)
+        return '.';
+    const base = [];
+    for (const segment of segments.slice(0, -1)) {
+        if (segment === '')
+            continue;
+        if (isDynamicSegment(segment))
+            break;
+        base.push(segment);
+    }
+    // An absolute pattern must stay absolute, or `path.resolve(changeDir, base)`
+    // rebases `/etc/*` inside the change directory and the containment check
+    // passes for a pattern that globs the filesystem root.
+    if (pattern.startsWith('/'))
+        return `/${base.join('/')}`;
+    return base.length > 0 ? base.join('/') : '.';
+}
+// brace-expansion 5 leaves the rest of a pattern literal when a non-expanding
+// group such as `{draft}` comes before a range. Expand one real group at a time.
+// NUL-prefixed so no `generates` value can forge them: `resolveArtifactOutputPath`
+// runs `path.join` first, which rejects a NUL byte. A single-character sentinel
+// such as U+0001 is a legal filename character, and a pattern containing one
+// would come back out of the expander as a brace.
+const LITERAL_BRACE_OPEN = '\u0000<';
+const LITERAL_BRACE_CLOSE = '\u0000>';
+function hasTopLevelExpansion(body) {
+    let depth = 0;
+    for (let index = 0; index < body.length; index += 1) {
+        const char = body[index];
+        if (char === '{')
+            depth += 1;
+        else if (char === '}')
+            depth = Math.max(0, depth - 1);
+        else if (depth === 0) {
+            if (char === ',')
+                return true;
+            if (char === '.' && body[index + 1] === '.')
+                return true;
+        }
+    }
+    return false;
+}
+function findTopLevelExpansion(pattern) {
+    const stack = [];
+    for (let index = 0; index < pattern.length; index += 1) {
+        const char = pattern[index];
+        if (char === '{') {
+            stack.push(index);
+        }
+        else if (char === '}' && stack.length > 0) {
+            const open = stack.pop();
+            if (open === undefined)
+                continue;
+            // Only the outermost group that actually expands. brace-expansion expands
+            // its nested groups in one linear pass. Peeling the innermost `{a,b}` first
+            // turns `{a,{a,{a,b}}}` into a binary tree, so a 16-deep pattern does not
+            // finish before the test timeout.
+            if (stack.length > 0)
+                continue;
+            const body = pattern.slice(open + 1, index);
+            if (!hasTopLevelExpansion(body)) {
+                // `{prefix{a,b}}` has no separator of its own, so the outer braces stay
+                // literal. Keep scanning inside them; a nested group may still expand.
+                const nested = findTopLevelExpansion(body);
+                if (!nested)
+                    continue;
+                return {
+                    pre: `${pattern.slice(0, open + 1)}${nested.pre}`,
+                    body: nested.body,
+                    post: `${nested.post}${pattern.slice(index)}`,
+                };
+            }
+            return { pre: pattern.slice(0, open), body, post: pattern.slice(index + 1) };
+        }
+    }
+    return null;
+}
+function assertExpansionBudget(pattern, count) {
+    if (count <= MAX_BRACE_EXPANSIONS)
+        return;
+    // A pattern this wide can run to thousands of characters; quote only its start.
+    const shown = pattern.length > 80 ? `${pattern.slice(0, 80)}...` : pattern;
+    throw new Error(`Artifact output pattern expands to more than ${MAX_BRACE_EXPANSIONS} patterns: ${shown}`);
+}
+function expandArtifactBraces(pattern) {
+    if (pattern.includes('\u0000')) {
+        throw new Error('Artifact output pattern contains a NUL byte');
+    }
+    const pending = [pattern];
+    const finished = [];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current === undefined)
+            break;
+        const group = findTopLevelExpansion(current);
+        if (!group) {
+            finished.push(current.replaceAll(LITERAL_BRACE_OPEN, '{').replaceAll(LITERAL_BRACE_CLOSE, '}'));
+            continue;
+        }
+        const wrapped = `{${group.body}}`;
+        // `max` makes this budget the binding one. Without it `{1..1000000000}`
+        // allocates brace-expansion's own 100,000-result default before the check
+        // below rejects it. `max` truncates silently, so ask for one result more
+        // than the budget allows: a result that long means the pattern is over
+        // budget rather than fully expanded. A truncated group never looks literal,
+        // because its first alternative is not the group itself.
+        const remaining = Math.max(MAX_BRACE_EXPANSIONS - (pending.length + finished.length), 0);
+        const alternatives = expand(wrapped, { max: remaining + 1 });
+        if (alternatives.length === 1 && alternatives[0] === wrapped) {
+            pending.push(`${group.pre}${LITERAL_BRACE_OPEN}${group.body}${LITERAL_BRACE_CLOSE}${group.post}`);
+            continue;
+        }
+        // Checked before the push so the budget bounds memory, not just the result.
+        assertExpansionBudget(pattern, pending.length + finished.length + alternatives.length);
+        for (const alternative of alternatives) {
+            pending.push(`${group.pre}${alternative}${group.post}`);
+        }
+    }
+    const normalized = finished
+        .map((value) => value.replace(DUPLICATE_SLASH_RE, '/'))
+        .filter((value) => value.length > 0);
+    return normalized.length > 0 ? normalized : [pattern];
+}
+/**
+ * One directory level. picomatch matches the segment; readdir keeps symlink
+ * entries tinyglobby would drop when followSymbolicLinks is false.
+ */
+function listDirectoryMatches(directory, segment) {
+    let entries;
+    try {
+        entries = fs.readdirSync(directory, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    const isMatch = picomatch(segment, {
+        dot: false,
+        nobrace: true,
+        noglobstar: true,
+        posix: true,
+    });
+    const names = [];
+    for (const entry of entries) {
+        if (isMatch(entry.name))
+            names.push(entry.name);
+    }
+    return names;
+}
 function hasBraceExpansion(pattern) {
     const openings = [];
     for (let index = 0; index < pattern.length; index += 1) {
@@ -94,12 +271,16 @@ function assertGlobDirectoryTraversal(changeDir, currentDir, directorySegments,
             // `**` may consume no directory at all.
             assertGlobDirectoryTraversal(changeDir, canonicalDir, directorySegments, segmentIndex + 1, visited, canonicalChangeDir, ancestors);
         }
-        const matches = fg.sync(segment === '**' ? '*' : segment, {
-            cwd: canonicalDir,
-            onlyFiles: false,
-            followSymbolicLinks: false,
-            deep: 1,
-        });
+        // `.` and `..` are not directory entries. Resolve them directly so a
+        // `**/../` pattern is confined before any glob runs.
+        if (segment === '' || segment === '.' || segment === '..') {
+            const candidate = path.resolve(canonicalDir, segment === '' ? '.' : segment);
+            const canonicalCandidate = FileSystemUtils.canonicalizeExistingPath(candidate);
+            FileSystemUtils.assertPathWithin(canonicalChangeDir, canonicalCandidate);
+            assertGlobDirectoryTraversal(changeDir, canonicalCandidate, directorySegments, segmentIndex + 1, visited, canonicalChangeDir, ancestors);
+            return;
+        }
+        const matches = listDirectoryMatches(canonicalDir, segment === '**' ? '*' : segment);
         for (const match of matches) {
             const candidate = path.join(canonicalDir, match);
             try {
@@ -139,27 +320,21 @@ export function resolveArtifactOutputs(changeDir, generates) {
             return [];
         }
     }
-    const normalizedPattern = FileSystemUtils.toPosixPath(generates);
-    const globOptions = {
+    const normalizedPattern = FileSystemUtils.toPosixPath(generates).replace(DUPLICATE_SLASH_RE, '/');
+    // Expand braces before any filesystem access. tinyglobby has no generateTasks,
+    // and a `../` alternative is invisible until the braces are expanded.
+    const patterns = expandArtifactBraces(normalizedPattern);
+    for (const pattern of patterns) {
+        FileSystemUtils.assertPathWithin(changeDir, path.resolve(changeDir, globBase(pattern)));
+    }
+    for (const pattern of patterns) {
+        assertGlobDirectoryTraversal(changeDir, changeDir, pattern.split('/').slice(0, -1));
+    }
+    const matches = globby
+        .globSync(patterns, {
         cwd: changeDir,
-        onlyFiles: true,
-        absolute: true,
-        // Preserve linked artifact directories; confine traversal and concrete matches.
-        followSymbolicLinks: true,
-    };
-    // Task generation expands braces without accessing the filesystem. Validate
-    // every task base before globbing, including paths introduced by expansion.
-    const tasks = fg.generateTasks(normalizedPattern, globOptions);
-    for (const task of tasks) {
-        FileSystemUtils.assertPathWithin(changeDir, path.resolve(changeDir, task.base));
-    }
-    for (const task of tasks) {
-        for (const positivePattern of task.positive) {
-            assertGlobDirectoryTraversal(changeDir, changeDir, positivePattern.split('/').slice(0, -1));
-        }
-    }
-    const matches = fg
-        .sync(normalizedPattern, globOptions)
+        ...ARTIFACT_GLOB_OPTIONS,
+    })
         .map((match) => {
         const normalizedMatch = path.normalize(match);
         FileSystemUtils.assertPathWithin(changeDir, normalizedMatch);

package/dist/core/artifact-graph/resolver.d.ts

@@ -8,6 +8,12 @@ export declare class SchemaLoadError extends Error {
     readonly cause?: Error | undefined;
     constructor(message: string, schemaPath: string, cause?: Error | undefined);
 }
+/**
+ * Points the built-in schemas at another directory. The standalone binary has
+ * no package directory on disk, so it passes a function that extracts its
+ * embedded schemas; it runs only when a command first needs them.
+ */
+export declare function setPackageSchemasDir(resolveDir: () => string): void;
 /**
  * Gets the package's built-in schemas directory path.
  * Uses import.meta.url to resolve relative to the current module.

package/dist/core/artifact-graph/resolver.js

@@ -17,11 +17,22 @@ export class SchemaLoadError extends Error {
         this.name = 'SchemaLoadError';
     }
 }
+let packageSchemasDirOverride;
+/**
+ * Points the built-in schemas at another directory. The standalone binary has
+ * no package directory on disk, so it passes a function that extracts its
+ * embedded schemas; it runs only when a command first needs them.
+ */
+export function setPackageSchemasDir(resolveDir) {
+    packageSchemasDirOverride = resolveDir;
+}
 /**
  * Gets the package's built-in schemas directory path.
  * Uses import.meta.url to resolve relative to the current module.
  */
 export function getPackageSchemasDir() {
+    if (packageSchemasDirOverride)
+        return packageSchemasDirOverride();
     const currentFile = fileURLToPath(import.meta.url);
     // Navigate from dist/core/artifact-graph/ to package root's schemas/
     return path.join(path.dirname(currentFile), '..', '..', '..', 'schemas');

package/dist/core/available-tools.d.ts

@@ -5,6 +5,7 @@
  * for their configuration directories.
  */
 import { type AIToolOption } from './config.js';
+import { type FileView } from './file-view.js';
 /**
  * Scans the project path for AI tool configuration directories and returns
  * the tools that are present.
@@ -13,5 +14,5 @@ import { type AIToolOption } from './config.js';
  * directories). Otherwise checks the project's `skillsDir`, or managed skill
  * files in the user's home directory for a global skill target.
  */
-export declare function getAvailableTools(projectPath: string): AIToolOption[];
+export declare function getAvailableTools(projectPath: string, view?: FileView): AIToolOption[];
 //# sourceMappingURL=available-tools.d.ts.map

package/dist/core/available-tools.js

@@ -5,11 +5,11 @@
  * for their configuration directories.
  */
 import path from 'path';
-import * as fs from 'fs';
 import { AI_TOOLS } from './config.js';
 import { reconcileSharedSkillTargets } from './shared-skill-target.js';
 import { SKILL_NAMES } from './shared/tool-detection.js';
 import { resolveToolSkillsDir, toolSupportsSkills } from './shared/skill-paths.js';
+import { DISK_VIEW } from './file-view.js';
 /**
  * Scans the project path for AI tool configuration directories and returns
  * the tools that are present.
@@ -18,49 +18,29 @@ import { resolveToolSkillsDir, toolSupportsSkills } from './shared/skill-paths.j
  * directories). Otherwise checks the project's `skillsDir`, or managed skill
  * files in the user's home directory for a global skill target.
  */
-export function getAvailableTools(projectPath) {
+export function getAvailableTools(projectPath, view = DISK_VIEW) {
     const available = AI_TOOLS.filter((tool) => {
         if (!toolSupportsSkills(tool))
             return false;
         if (tool.globalSkillsDir) {
             const skillsDir = resolveToolSkillsDir(projectPath, tool);
-            return SKILL_NAMES.some((skillName) => fs.existsSync(path.join(skillsDir, skillName, 'SKILL.md')));
+            return SKILL_NAMES.some((skillName) => view.exists(path.join(skillsDir, skillName, 'SKILL.md')));
         }
         if (!tool.skillsDir)
             return false;
         if (tool.detectionPaths && tool.detectionPaths.length > 0) {
-            // statSync without .isDirectory() — detection paths can be files or directories
-            return tool.detectionPaths.some((p) => {
-                try {
-                    fs.statSync(path.join(projectPath, p));
-                    return true;
-                }
-                catch {
-                    return false;
-                }
-            });
-        }
-        const dirPath = path.join(projectPath, tool.skillsDir);
-        try {
-            return fs.statSync(dirPath).isDirectory();
-        }
-        catch {
-            return false;
+            // Presence, not type — detection paths can be files or directories
+            return tool.detectionPaths.some((p) => view.exists(path.join(projectPath, p)));
         }
+        return view.isDirectory(path.join(projectPath, tool.skillsDir));
     });
-    const activeProjectTools = new Set(reconcileSharedSkillTargets(projectPath, available.filter((tool) => tool.skillsDir)).map((tool) => tool.value));
+    const activeProjectTools = new Set(reconcileSharedSkillTargets(projectPath, available.filter((tool) => tool.skillsDir), view).map((tool) => tool.value));
     const hasIndependentDetectionPath = (tool) => (tool.detectionPaths ?? []).some((detectionPath) => {
         // Skill roots still go through managed-content reconciliation below;
         // their mere existence is not an independent tool signal.
         if (detectionPath.endsWith('/skills'))
             return false;
-        try {
-            fs.statSync(path.join(projectPath, detectionPath));
-            return true;
-        }
-        catch {
-            return false;
-        }
+        return view.exists(path.join(projectPath, detectionPath));
     });
     return available.filter((tool) => tool.globalSkillsDir ||
         hasIndependentDetectionPath(tool) ||

package/dist/core/completion-tip.d.ts

@@ -7,6 +7,29 @@ export interface CompletionTipOptions {
      */
     silent?: boolean;
 }
+/**
+ * Read the global config exactly as it sits on disk.
+ *
+ * Deliberately NOT `getGlobalConfig()`: that merges in defaults, and writing the
+ * merged result back would stamp `profile`/`delivery` into a file the user never
+ * set them in. `migrateIfNeeded` treats a raw `profile` as "already migrated",
+ * so that stamp would permanently suppress the one-time profile migration and
+ * cost users their installed workflow skills.
+ *
+ * Returns null when the file exists but cannot be read or parsed — a config we
+ * cannot understand is left strictly alone rather than overwritten.
+ */
+export declare function readRawConfig(): Record<string, unknown> | null;
+/**
+ * Record the flag, re-reading the config first and replacing the file by rename.
+ *
+ * Deciding whether to show the tip costs a `ps` spawn and a stat, and a sibling
+ * `openspec` process can write the same file in that window — on a first run
+ * that is exactly when telemetry mints `anonymousId`. Re-reading here keeps the
+ * write down to this one key, and the rename keeps a reader from ever seeing a
+ * half-written config.
+ */
+export declare function markConfigFlag(key: string): Promise<void>;
 /**
  * Print the completion tip once, the first time the CLI runs.
  * Never throws — a hint must not break a command.

package/dist/core/completion-tip.js

@@ -76,7 +76,7 @@ async function decideTip() {
  * Returns null when the file exists but cannot be read or parsed — a config we
  * cannot understand is left strictly alone rather than overwritten.
  */
-function readRawConfig() {
+export function readRawConfig() {
     const configPath = getGlobalConfigPath();
     if (!fs.existsSync(configPath)) {
         return {};
@@ -96,13 +96,13 @@ function readRawConfig() {
  * write down to this one key, and the rename keeps a reader from ever seeing a
  * half-written config.
  */
-async function markTipSeen() {
+export async function markConfigFlag(key) {
     const configPath = getGlobalConfigPath();
     const current = readRawConfig() ?? {};
     // The shared atomic writer: randomized temp name, owner-only mode, temp file
     // removed on failure. A predictable `<config>.<pid>.tmp` at the default mode
     // is both guessable and world-readable once renamed over the config.
-    await writeFileAtomically(configPath, JSON.stringify({ ...current, completionTipSeen: true }, null, 2) + '\n');
+    await writeFileAtomically(configPath, JSON.stringify({ ...current, [key]: true }, null, 2) + '\n');
 }
 /**
  * Print the completion tip once, the first time the CLI runs.
@@ -123,7 +123,7 @@ export async function maybeShowCompletionTip(options = {}) {
         const decision = await decideTip();
         // Record before printing: if the flag cannot be persisted, staying quiet
         // beats reprinting the tip on every future run.
-        await markTipSeen();
+        await markConfigFlag('completionTipSeen');
         if (decision === 'show') {
             console.error(`\n${COMPLETION_TIP_MESSAGE}`);
         }

package/dist/core/completions/command-registry.js

@@ -52,8 +52,23 @@ export const COMMAND_REGISTRY = [
                 name: 'force',
                 description: 'Force update even when tools are up to date',
             },
+            {
+                name: 'dry-run',
+                description: 'Report what the update would change without writing anything',
+            },
+            {
+                name: 'json',
+                description: 'With --dry-run, print the planned changes as JSON',
+            },
         ],
     },
+    {
+        name: 'install',
+        description: 'Install the standalone openspec, which runs without Node.js (latest release unless [version] is given)',
+        acceptsPositional: true,
+        positionals: [{ name: 'version', optional: true }],
+        flags: [],
+    },
     {
         name: 'version',
         description: 'Report the installed OpenSpec version and update availability',

package/dist/core/completions/completion-provider.js

@@ -75,7 +75,7 @@ export class CompletionProvider {
         }
         // Fetch fresh data. The resolver (and the yaml and zod it parses schemas
         // with) loads only here: completing changes or specs never needs it, and
-        // the artifact-graph barrel would also pull in fast-glob.
+        // the artifact-graph barrel would also pull in tinyglobby.
         const { listSchemas } = await import('../artifact-graph/resolver.js');
         const schemaNames = listSchemas(this.projectRoot);
         // Update cache

package/dist/core/config-schema.d.ts

@@ -20,6 +20,7 @@ export declare const GlobalConfigSchema: z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$loose>>;
     completionTipSeen: z.ZodOptional<z.ZodBoolean>;
+    standaloneTipSeen: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$loose>;
 export type GlobalConfigType = z.infer<typeof GlobalConfigSchema>;
 /**

package/dist/core/config-schema.js

@@ -34,6 +34,7 @@ export const GlobalConfigSchema = z
         .optional(),
     // Runtime-managed (like telemetry.noticeSeen); not user-settable via CLI set.
     completionTipSeen: z.boolean().optional(),
+    standaloneTipSeen: z.boolean().optional(),
 })
     .passthrough();
 /**

package/dist/core/file-view.d.ts

@@ -0,0 +1,13 @@
+/**
+ * How a check reads the files it inspects. Normally the disk. `update
+ * --dry-run` passes the tree as it has planned it, so a step that reads what
+ * an earlier step wrote sees the same thing it would in a real update.
+ */
+export interface FileView {
+    exists(filePath: string): boolean;
+    /** Throws, like `fs.readFileSync`, when the file is absent. */
+    read(filePath: string): string;
+    isDirectory(filePath: string): boolean;
+}
+export declare const DISK_VIEW: FileView;
+//# sourceMappingURL=file-view.d.ts.map

package/dist/core/file-view.js

@@ -0,0 +1,14 @@
+import * as fs from 'fs';
+export const DISK_VIEW = {
+    exists: (filePath) => fs.existsSync(filePath),
+    read: (filePath) => fs.readFileSync(filePath, 'utf-8'),
+    isDirectory: (filePath) => {
+        try {
+            return fs.statSync(filePath).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    },
+};
+//# sourceMappingURL=file-view.js.map

package/dist/core/github-copilot/cloud-agent.d.ts

@@ -28,6 +28,14 @@ export declare const COPILOT_CLOUD_FILES: {
     readonly setupSteps: string;
     readonly agent: string;
 };
+/**
+ * Every change the cloud-file sync makes on disk. `update --dry-run` passes a
+ * recorder, so the plan comes from this same code rather than a description.
+ */
+export interface CopilotCloudFileOps {
+    writeFile(filePath: string, content: string): Promise<void>;
+    removeFile(filePath: string): Promise<void>;
+}
 /**
  * Reconcile Copilot cloud agent files in the project directory.
  * Creates missing files and refreshes recognized legacy generated files while
@@ -35,7 +43,7 @@ export declare const COPILOT_CLOUD_FILES: {
  *
  * @returns Object indicating which files were written.
  */
-export declare function writeCopilotCloudFiles(projectPath: string): Promise<{
+export declare function writeCopilotCloudFiles(projectPath: string, ops?: CopilotCloudFileOps): Promise<{
     setupStepsWritten: boolean;
     agentWritten: boolean;
 }>;
@@ -45,7 +53,7 @@ export declare function writeCopilotCloudFiles(projectPath: string): Promise<{
  *
  * @returns Number of files removed.
  */
-export declare function removeCopilotCloudFiles(projectPath: string): Promise<number>;
+export declare function removeCopilotCloudFiles(projectPath: string, ops?: CopilotCloudFileOps): Promise<number>;
 /**
  * Read the persisted opt-in for Copilot cloud-file generation.
  *