@fission-ai/openspec 1.4.1 → 1.6.0-beta.1

package/dist/core/workspace/registry.js

@@ -1,146 +0,0 @@
-import * as nodeFs from 'node:fs';
-import { z } from 'zod';
-import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
-import { getGlobalDataDir } from '../global-config.js';
-import { FileSystemUtils } from '../../utils/file-system.js';
-import { validateWorkspaceName } from './foundation.js';
-import { isWorkspaceRoot, readWorkspaceViewState } from './state-io.js';
-const fs = nodeFs.promises;
-export const MANAGED_WORKSPACES_DIR_NAME = 'workspaces';
-export const WORKSPACE_REGISTRY_FILE_NAME = 'registry.yaml';
-function joinWorkspacePath(basePath, ...segments) {
-    return FileSystemUtils.joinPath(basePath, ...segments);
-}
-async function pathIsFile(filePath) {
-    try {
-        return (await fs.stat(filePath)).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-async function pathIsDirectory(dirPath) {
-    try {
-        return (await fs.stat(dirPath)).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-function formatZodIssues(error) {
-    return error.issues
-        .map((issue) => {
-        const location = issue.path.length > 0 ? issue.path.join('.') : 'root';
-        return `${location}: ${issue.message}`;
-    })
-        .join('; ');
-}
-function parseYamlObject(content, label) {
-    try {
-        return parseYaml(content);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Invalid ${label}: ${message}`);
-    }
-}
-function assertValidMapKeys(keys, validator, label) {
-    for (const key of keys) {
-        try {
-            validator(key);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`Invalid ${label} '${key}': ${message}`);
-        }
-    }
-}
-const RegistryStateSchema = z.object({
-    version: z.literal(1),
-    workspaces: z.record(z.string(), z.string()),
-}).strict();
-export function getManagedWorkspacesDir(options = {}) {
-    return joinWorkspacePath(options.globalDataDir ?? getGlobalDataDir(), MANAGED_WORKSPACES_DIR_NAME);
-}
-export function getManagedWorkspaceRoot(workspaceName, options = {}) {
-    validateWorkspaceName(workspaceName);
-    return joinWorkspacePath(getManagedWorkspacesDir(options), workspaceName);
-}
-export function getWorkspaceRegistryPath(options = {}) {
-    return joinWorkspacePath(getManagedWorkspacesDir(options), WORKSPACE_REGISTRY_FILE_NAME);
-}
-export function parseWorkspaceRegistryState(content) {
-    const raw = parseYamlObject(content, 'workspace registry state');
-    const result = RegistryStateSchema.safeParse(raw);
-    if (!result.success) {
-        throw new Error(`Invalid workspace registry state: ${formatZodIssues(result.error)}`);
-    }
-    assertValidMapKeys(Object.keys(result.data.workspaces), validateWorkspaceName, 'workspace registry name');
-    return {
-        version: 1,
-        workspaces: result.data.workspaces,
-    };
-}
-export function serializeWorkspaceRegistryState(state) {
-    assertValidMapKeys(Object.keys(state.workspaces), validateWorkspaceName, 'workspace registry name');
-    for (const [workspaceName, workspaceRoot] of Object.entries(state.workspaces)) {
-        if (typeof workspaceRoot !== 'string') {
-            throw new Error(`Invalid workspace registry entry '${workspaceName}': path must be a string`);
-        }
-    }
-    return stringifyYaml({
-        version: 1,
-        workspaces: state.workspaces,
-    });
-}
-export function listWorkspaceRegistryEntries(registry) {
-    return Object.entries(registry.workspaces)
-        .map(([name, workspaceRoot]) => ({ name, workspaceRoot }))
-        .sort((a, b) => a.name.localeCompare(b.name));
-}
-export async function listKnownWorkspaceEntries(options = {}) {
-    const legacyRegistry = await readWorkspaceRegistryState(options);
-    const workspaces = new Map(Object.entries(legacyRegistry?.workspaces ?? {}));
-    for (const entry of await listManagedWorkspaceEntries(options)) {
-        workspaces.set(entry.name, entry.workspaceRoot);
-    }
-    return [...workspaces.entries()]
-        .map(([name, workspaceRoot]) => ({ name, workspaceRoot }))
-        .sort((a, b) => a.name.localeCompare(b.name));
-}
-export async function listManagedWorkspaceEntries(options = {}) {
-    const workspacesDir = getManagedWorkspacesDir(options);
-    if (!(await pathIsDirectory(workspacesDir))) {
-        return [];
-    }
-    const entries = await fs.readdir(workspacesDir, { withFileTypes: true });
-    const workspaces = [];
-    for (const entry of entries) {
-        if (!entry.isDirectory()) {
-            continue;
-        }
-        const workspaceRoot = FileSystemUtils.canonicalizeExistingPath(joinWorkspacePath(workspacesDir, entry.name));
-        if (!(await isWorkspaceRoot(workspaceRoot))) {
-            continue;
-        }
-        try {
-            const state = await readWorkspaceViewState(workspaceRoot);
-            workspaces.push({ name: state.name, workspaceRoot });
-        }
-        catch {
-            workspaces.push({ name: entry.name, workspaceRoot });
-        }
-    }
-    return workspaces.sort((a, b) => a.name.localeCompare(b.name));
-}
-export async function readWorkspaceRegistryState(options = {}) {
-    const registryPath = getWorkspaceRegistryPath(options);
-    if (!(await pathIsFile(registryPath))) {
-        return null;
-    }
-    return parseWorkspaceRegistryState(await fs.readFile(registryPath, 'utf-8'));
-}
-export async function writeWorkspaceRegistryState(state, options = {}) {
-    await FileSystemUtils.writeFile(getWorkspaceRegistryPath(options), serializeWorkspaceRegistryState(state));
-}
-//# sourceMappingURL=registry.js.map

package/dist/core/workspace/skills.d.ts

@@ -1,57 +0,0 @@
-import { type AIToolOption } from '../config.js';
-import { type Delivery, type Profile } from '../global-config.js';
-import type { WorkspaceSkillState } from './foundation.js';
-export interface WorkspaceSkillAgentResult {
-    tool_id: string;
-    name: string;
-    skills_path: string;
-    workflow_ids: string[];
-}
-export interface WorkspaceSkillRemovedResult extends WorkspaceSkillAgentResult {
-    reason: 'agent_unselected' | 'workflow_unselected';
-}
-export interface WorkspaceSkillSkippedResult {
-    tool_id?: string;
-    name?: string;
-    reason: string;
-    message: string;
-}
-export interface WorkspaceSkillFailedResult {
-    tool_id: string;
-    name: string;
-    error: string;
-}
-export interface WorkspaceSkillInstallationReport {
-    profile: Profile;
-    delivery: Delivery;
-    workflow_ids: string[];
-    selected_agents: string[];
-    skills_only: true;
-    delivery_notice: string | null;
-    generated: WorkspaceSkillAgentResult[];
-    added: WorkspaceSkillAgentResult[];
-    refreshed: WorkspaceSkillAgentResult[];
-    removed: WorkspaceSkillRemovedResult[];
-    skipped: WorkspaceSkillSkippedResult[];
-    failed: WorkspaceSkillFailedResult[];
-}
-type WorkspaceSkillCapableTool = AIToolOption & {
-    skillsDir: string;
-};
-export declare function getCurrentWorkspaceSkillProfileSelection(): {
-    profile: Profile;
-    delivery: Delivery;
-    workflow_ids: string[];
-};
-export declare function hasWorkspaceSkillProfileDrift(state: {
-    workspace_skills?: WorkspaceSkillState;
-} | null | undefined): boolean;
-export declare function getWorkspaceSkillCapableTools(): WorkspaceSkillCapableTool[];
-export declare function getWorkspaceSkillToolIds(): string[];
-export declare function parseWorkspaceSkillToolsValue(rawTools: string): string[];
-export declare function createWorkspaceSkillSkippedReport(reason: string, message: string): WorkspaceSkillInstallationReport;
-export declare function getWorkspaceSkillDirectory(workspaceRoot: string, toolId: string): string;
-export declare function generateWorkspaceAgentSkills(workspaceRoot: string, selectedAgentIds: string[]): Promise<WorkspaceSkillInstallationReport>;
-export declare function updateWorkspaceAgentSkills(workspaceRoot: string, selectedAgentIds: string[], previousSkillState?: WorkspaceSkillState): Promise<WorkspaceSkillInstallationReport>;
-export {};
-//# sourceMappingURL=skills.d.ts.map

package/dist/core/workspace/skills.js

@@ -1,334 +0,0 @@
-import * as nodeFs from 'node:fs';
-import { createRequire } from 'node:module';
-import { FileSystemUtils } from '../../utils/file-system.js';
-import { transformToHyphenCommands } from '../../utils/command-references.js';
-import { AI_TOOLS } from '../config.js';
-import { getGlobalConfig } from '../global-config.js';
-import { getProfileWorkflows } from '../profiles.js';
-import { generateSkillContent, getSkillTemplates, getToolSkillStatus, getToolsWithSkillsDir, extractGeneratedByVersion, } from '../shared/index.js';
-const require = createRequire(import.meta.url);
-const { version: OPENSPEC_VERSION } = require('../../../package.json');
-const fs = nodeFs.promises;
-function resolveWorkspaceSkillProfileContext() {
-    const globalConfig = getGlobalConfig();
-    const profile = globalConfig.profile ?? 'core';
-    const delivery = globalConfig.delivery ?? 'both';
-    const workflowIds = [...getProfileWorkflows(profile, globalConfig.workflows)];
-    const deliveryNotice = delivery === 'skills'
-        ? null
-        : 'Workspace setup installs skills only; workspace command generation is not part of this slice.';
-    return {
-        profile,
-        delivery,
-        workflowIds,
-        deliveryNotice,
-    };
-}
-export function getCurrentWorkspaceSkillProfileSelection() {
-    const profileContext = resolveWorkspaceSkillProfileContext();
-    return {
-        profile: profileContext.profile,
-        delivery: profileContext.delivery,
-        workflow_ids: profileContext.workflowIds,
-    };
-}
-function arraysEqual(left, right) {
-    const leftValues = left ?? [];
-    if (leftValues.length !== right.length) {
-        return false;
-    }
-    const leftSet = new Set(leftValues);
-    const rightSet = new Set(right);
-    if (leftSet.size !== rightSet.size) {
-        return false;
-    }
-    return [...leftSet].every((value) => rightSet.has(value));
-}
-export function hasWorkspaceSkillProfileDrift(state) {
-    const workspaceSkills = state?.workspace_skills;
-    if (!workspaceSkills) {
-        return false;
-    }
-    const current = getCurrentWorkspaceSkillProfileSelection();
-    return (workspaceSkills.last_applied_profile !== current.profile ||
-        workspaceSkills.last_applied_delivery !== current.delivery ||
-        !arraysEqual(workspaceSkills.last_applied_workflow_ids, current.workflow_ids));
-}
-function makeBaseWorkspaceSkillReport(selectedAgentIds, profileContext = resolveWorkspaceSkillProfileContext()) {
-    return {
-        profile: profileContext.profile,
-        delivery: profileContext.delivery,
-        workflow_ids: profileContext.workflowIds,
-        selected_agents: selectedAgentIds,
-        skills_only: true,
-        delivery_notice: profileContext.deliveryNotice,
-        generated: [],
-        added: [],
-        refreshed: [],
-        removed: [],
-        skipped: [],
-        failed: [],
-    };
-}
-export function getWorkspaceSkillCapableTools() {
-    return AI_TOOLS.filter((tool) => Boolean(tool.skillsDir));
-}
-export function getWorkspaceSkillToolIds() {
-    return getToolsWithSkillsDir();
-}
-export function parseWorkspaceSkillToolsValue(rawTools) {
-    const raw = rawTools.trim();
-    if (raw.length === 0) {
-        throw new Error('The --tools option requires a value. Use "all", "none", or a comma-separated list of agent IDs.');
-    }
-    const availableTools = getWorkspaceSkillToolIds();
-    const availableSet = new Set(availableTools);
-    const availableList = ['all', 'none', ...availableTools].join(', ');
-    const lowerRaw = raw.toLowerCase();
-    if (lowerRaw === 'all') {
-        return availableTools;
-    }
-    if (lowerRaw === 'none') {
-        return [];
-    }
-    const tokens = raw
-        .split(',')
-        .map((token) => token.trim())
-        .filter((token) => token.length > 0);
-    if (tokens.length === 0) {
-        throw new Error('The --tools option requires at least one agent ID when not using "all" or "none".');
-    }
-    const normalizedTokens = tokens.map((token) => token.toLowerCase());
-    if (normalizedTokens.some((token) => token === 'all' || token === 'none')) {
-        throw new Error('Cannot combine reserved values "all" or "none" with specific agent IDs.');
-    }
-    const invalidTokens = tokens.filter((_token, index) => !availableSet.has(normalizedTokens[index]));
-    if (invalidTokens.length > 0) {
-        throw new Error(`Invalid agent(s): ${invalidTokens.join(', ')}. Available values: ${availableList}`);
-    }
-    const deduped = [];
-    for (const token of normalizedTokens) {
-        if (!deduped.includes(token)) {
-            deduped.push(token);
-        }
-    }
-    return deduped;
-}
-export function createWorkspaceSkillSkippedReport(reason, message) {
-    const report = makeBaseWorkspaceSkillReport([]);
-    report.skipped.push({
-        reason,
-        message,
-    });
-    return report;
-}
-function getWorkspaceSkillTool(toolId) {
-    const tool = getWorkspaceSkillCapableTools().find((candidate) => candidate.value === toolId);
-    if (!tool) {
-        throw new Error(`Unknown workspace skill agent '${toolId}'.`);
-    }
-    return tool;
-}
-function getWorkspaceSkillDirectoryForTool(workspaceRoot, tool) {
-    return FileSystemUtils.joinPath(workspaceRoot, tool.skillsDir, 'skills');
-}
-export function getWorkspaceSkillDirectory(workspaceRoot, toolId) {
-    return getWorkspaceSkillDirectoryForTool(workspaceRoot, getWorkspaceSkillTool(toolId));
-}
-function makeAgentResult(workspaceRoot, tool, workflowIds) {
-    return {
-        tool_id: tool.value,
-        name: tool.name,
-        skills_path: getWorkspaceSkillDirectoryForTool(workspaceRoot, tool),
-        workflow_ids: workflowIds,
-    };
-}
-function getManagedWorkspaceSkillEntries() {
-    return getSkillTemplates().map(({ workflowId, dirName }) => ({ workflowId, dirName }));
-}
-async function pathExists(targetPath) {
-    try {
-        await fs.access(targetPath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function isOpenSpecManagedSkillDir(skillDir) {
-    const skillFile = FileSystemUtils.joinPath(skillDir, 'SKILL.md');
-    return extractGeneratedByVersion(skillFile) !== null;
-}
-async function removeManagedWorkflowSkillDirs(workspaceRoot, tool, desiredWorkflowIds, reason) {
-    const desiredSet = new Set(desiredWorkflowIds);
-    const skillsDir = getWorkspaceSkillDirectoryForTool(workspaceRoot, tool);
-    const removedWorkflowIds = [];
-    for (const { workflowId, dirName } of getManagedWorkspaceSkillEntries()) {
-        if (desiredSet.has(workflowId)) {
-            continue;
-        }
-        const skillDir = FileSystemUtils.joinPath(skillsDir, dirName);
-        if (!(await pathExists(skillDir))) {
-            continue;
-        }
-        if (!isOpenSpecManagedSkillDir(skillDir)) {
-            continue;
-        }
-        await fs.rm(skillDir, { recursive: true, force: true });
-        removedWorkflowIds.push(workflowId);
-    }
-    if (removedWorkflowIds.length === 0) {
-        return null;
-    }
-    return {
-        ...makeAgentResult(workspaceRoot, tool, removedWorkflowIds),
-        reason,
-    };
-}
-export async function generateWorkspaceAgentSkills(workspaceRoot, selectedAgentIds) {
-    const profileContext = resolveWorkspaceSkillProfileContext();
-    const report = makeBaseWorkspaceSkillReport(selectedAgentIds, profileContext);
-    if (selectedAgentIds.length === 0) {
-        report.skipped.push({
-            reason: 'no_agents_selected',
-            message: 'No workspace agent skills were selected.',
-        });
-        return report;
-    }
-    const skillTemplates = getSkillTemplates(profileContext.workflowIds);
-    if (skillTemplates.length === 0) {
-        for (const toolId of selectedAgentIds) {
-            const tool = getWorkspaceSkillTool(toolId);
-            report.skipped.push({
-                tool_id: tool.value,
-                name: tool.name,
-                reason: 'no_profile_workflows',
-                message: 'The active global profile does not select any workflows.',
-            });
-        }
-        return report;
-    }
-    for (const toolId of selectedAgentIds) {
-        const tool = getWorkspaceSkillTool(toolId);
-        const wasConfigured = getToolSkillStatus(workspaceRoot, tool.value).configured;
-        try {
-            const skillsDir = getWorkspaceSkillDirectoryForTool(workspaceRoot, tool);
-            const transformer = tool.value === 'opencode' || tool.value === 'pi' ? transformToHyphenCommands : undefined;
-            for (const { template, dirName } of skillTemplates) {
-                const skillFile = FileSystemUtils.joinPath(skillsDir, dirName, 'SKILL.md');
-                const skillContent = generateSkillContent(template, OPENSPEC_VERSION, transformer);
-                await FileSystemUtils.writeFile(skillFile, skillContent);
-            }
-            const result = makeAgentResult(workspaceRoot, tool, profileContext.workflowIds);
-            if (wasConfigured) {
-                report.refreshed.push(result);
-            }
-            else {
-                report.generated.push(result);
-            }
-        }
-        catch (error) {
-            report.failed.push({
-                tool_id: tool.value,
-                name: tool.name,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    return report;
-}
-export async function updateWorkspaceAgentSkills(workspaceRoot, selectedAgentIds, previousSkillState) {
-    const profileContext = resolveWorkspaceSkillProfileContext();
-    const report = makeBaseWorkspaceSkillReport(selectedAgentIds, profileContext);
-    const previousSelectedAgentIds = previousSkillState?.selected_agents ?? [];
-    const previousSelectedSet = new Set(previousSelectedAgentIds);
-    const selectedSet = new Set(selectedAgentIds);
-    const skillTemplates = getSkillTemplates(profileContext.workflowIds);
-    for (const toolId of previousSelectedAgentIds) {
-        if (selectedSet.has(toolId)) {
-            continue;
-        }
-        const tool = getWorkspaceSkillTool(toolId);
-        try {
-            const removed = await removeManagedWorkflowSkillDirs(workspaceRoot, tool, [], 'agent_unselected');
-            if (removed) {
-                report.removed.push(removed);
-            }
-        }
-        catch (error) {
-            report.failed.push({
-                tool_id: tool.value,
-                name: tool.name,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    if (selectedAgentIds.length === 0) {
-        if (report.removed.length === 0) {
-            report.skipped.push({
-                reason: previousSkillState ? 'no_agents_selected' : 'no_stored_agent_selection',
-                message: previousSkillState
-                    ? 'No workspace agent skills were selected.'
-                    : 'No workspace agent skill selection is stored. Pass --tools <ids> to install skills.',
-            });
-        }
-        return report;
-    }
-    if (skillTemplates.length === 0) {
-        for (const toolId of selectedAgentIds) {
-            const tool = getWorkspaceSkillTool(toolId);
-            try {
-                const removed = await removeManagedWorkflowSkillDirs(workspaceRoot, tool, [], 'workflow_unselected');
-                if (removed) {
-                    report.removed.push(removed);
-                }
-            }
-            catch (error) {
-                report.failed.push({
-                    tool_id: tool.value,
-                    name: tool.name,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-            report.skipped.push({
-                tool_id: tool.value,
-                name: tool.name,
-                reason: 'no_profile_workflows',
-                message: 'The active global profile does not select any workflows.',
-            });
-        }
-        return report;
-    }
-    for (const toolId of selectedAgentIds) {
-        const tool = getWorkspaceSkillTool(toolId);
-        try {
-            const skillsDir = getWorkspaceSkillDirectoryForTool(workspaceRoot, tool);
-            const transformer = tool.value === 'opencode' || tool.value === 'pi' ? transformToHyphenCommands : undefined;
-            for (const { template, dirName } of skillTemplates) {
-                const skillFile = FileSystemUtils.joinPath(skillsDir, dirName, 'SKILL.md');
-                const skillContent = generateSkillContent(template, OPENSPEC_VERSION, transformer);
-                await FileSystemUtils.writeFile(skillFile, skillContent);
-            }
-            const removed = await removeManagedWorkflowSkillDirs(workspaceRoot, tool, profileContext.workflowIds, 'workflow_unselected');
-            if (removed) {
-                report.removed.push(removed);
-            }
-            const result = makeAgentResult(workspaceRoot, tool, profileContext.workflowIds);
-            if (previousSelectedSet.has(toolId)) {
-                report.refreshed.push(result);
-            }
-            else {
-                report.added.push(result);
-            }
-        }
-        catch (error) {
-            report.failed.push({
-                tool_id: tool.value,
-                name: tool.name,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    return report;
-}
-//# sourceMappingURL=skills.js.map

package/dist/core/workspace/state-io.d.ts

@@ -1,10 +0,0 @@
-import { type WorkspaceViewState } from './foundation.js';
-export declare function isWorkspaceRoot(candidateRoot: string): Promise<boolean>;
-export declare function findWorkspaceRoot(startPath?: string): Promise<string | null>;
-export declare function workspaceStateFileExistsSync(workspaceRoot: string): boolean;
-export declare function readWorkspaceViewState(workspaceRoot: string): Promise<WorkspaceViewState>;
-export declare function readWorkspaceViewStateSync(workspaceRoot: string): WorkspaceViewState | null;
-export declare function readOptionalWorkspaceViewState(workspaceRoot: string): Promise<WorkspaceViewState | null>;
-export declare function writeWorkspaceViewState(workspaceRoot: string, state: WorkspaceViewState): Promise<void>;
-export declare function workspaceChangesDirExists(workspaceRoot: string): Promise<boolean>;
-//# sourceMappingURL=state-io.d.ts.map

package/dist/core/workspace/state-io.js

@@ -1,121 +0,0 @@
-import * as nodeFs from 'node:fs';
-import * as path from 'node:path';
-import { FileSystemUtils } from '../../utils/file-system.js';
-import { getWorkspaceChangesDir, getWorkspaceMetadataDir, getWorkspaceViewStatePath, parseWorkspaceViewState, serializeWorkspaceViewState, } from './foundation.js';
-import { getWorkspaceLegacyLocalStatePath, getWorkspaceLegacySharedStatePath, parseWorkspaceLocalState, parseWorkspaceSharedState, workspaceStatePartsToViewState, } from './legacy-state.js';
-const fs = nodeFs.promises;
-async function pathIsFile(filePath) {
-    try {
-        return (await fs.stat(filePath)).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-async function pathIsDirectory(dirPath) {
-    try {
-        return (await fs.stat(dirPath)).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-function pathExistsAsFile(filePath) {
-    try {
-        return nodeFs.statSync(filePath).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-function isFileNotFoundError(error) {
-    return (typeof error === 'object' &&
-        error !== null &&
-        'code' in error &&
-        error.code === 'ENOENT');
-}
-async function getSearchStartDirectory(startPath) {
-    const resolvedStart = path.resolve(startPath);
-    try {
-        const stats = await fs.stat(resolvedStart);
-        const searchStart = stats.isDirectory() ? resolvedStart : path.dirname(resolvedStart);
-        return FileSystemUtils.canonicalizeExistingPath(searchStart);
-    }
-    catch {
-        return resolvedStart;
-    }
-}
-export async function isWorkspaceRoot(candidateRoot) {
-    return ((await pathIsFile(getWorkspaceViewStatePath(candidateRoot))) ||
-        (await pathIsFile(getWorkspaceLegacySharedStatePath(candidateRoot))));
-}
-export async function findWorkspaceRoot(startPath = process.cwd()) {
-    let currentDir = await getSearchStartDirectory(startPath);
-    while (true) {
-        if (await isWorkspaceRoot(currentDir)) {
-            return FileSystemUtils.canonicalizeExistingPath(currentDir);
-        }
-        const parentDir = path.dirname(currentDir);
-        if (parentDir === currentDir) {
-            return null;
-        }
-        currentDir = parentDir;
-    }
-}
-export function workspaceStateFileExistsSync(workspaceRoot) {
-    return (pathExistsAsFile(getWorkspaceViewStatePath(workspaceRoot)) ||
-        pathExistsAsFile(getWorkspaceLegacySharedStatePath(workspaceRoot)));
-}
-export async function readWorkspaceViewState(workspaceRoot) {
-    const viewStatePath = getWorkspaceViewStatePath(workspaceRoot);
-    if (await pathIsFile(viewStatePath)) {
-        return parseWorkspaceViewState(await fs.readFile(viewStatePath, 'utf-8'));
-    }
-    const legacySharedState = parseWorkspaceSharedState(await fs.readFile(getWorkspaceLegacySharedStatePath(workspaceRoot), 'utf-8'));
-    let legacyLocalState = null;
-    try {
-        legacyLocalState = parseWorkspaceLocalState(await fs.readFile(getWorkspaceLegacyLocalStatePath(workspaceRoot), 'utf-8'));
-    }
-    catch (error) {
-        if (!isFileNotFoundError(error)) {
-            throw error;
-        }
-    }
-    return workspaceStatePartsToViewState(legacySharedState, legacyLocalState);
-}
-export function readWorkspaceViewStateSync(workspaceRoot) {
-    const viewStatePath = getWorkspaceViewStatePath(workspaceRoot);
-    if (pathExistsAsFile(viewStatePath)) {
-        return parseWorkspaceViewState(nodeFs.readFileSync(viewStatePath, 'utf-8'));
-    }
-    const legacySharedPath = getWorkspaceLegacySharedStatePath(workspaceRoot);
-    if (!pathExistsAsFile(legacySharedPath)) {
-        return null;
-    }
-    const legacySharedState = parseWorkspaceSharedState(nodeFs.readFileSync(legacySharedPath, 'utf-8'));
-    const legacyLocalPath = getWorkspaceLegacyLocalStatePath(workspaceRoot);
-    const legacyLocalState = pathExistsAsFile(legacyLocalPath)
-        ? parseWorkspaceLocalState(nodeFs.readFileSync(legacyLocalPath, 'utf-8'))
-        : null;
-    return workspaceStatePartsToViewState(legacySharedState, legacyLocalState);
-}
-export async function readOptionalWorkspaceViewState(workspaceRoot) {
-    try {
-        return await readWorkspaceViewState(workspaceRoot);
-    }
-    catch (error) {
-        if (isFileNotFoundError(error)) {
-            return null;
-        }
-        throw error;
-    }
-}
-export async function writeWorkspaceViewState(workspaceRoot, state) {
-    const content = serializeWorkspaceViewState(state);
-    await FileSystemUtils.createDirectory(getWorkspaceMetadataDir(workspaceRoot));
-    await FileSystemUtils.writeFile(getWorkspaceViewStatePath(workspaceRoot), content);
-}
-export async function workspaceChangesDirExists(workspaceRoot) {
-    return pathIsDirectory(getWorkspaceChangesDir(workspaceRoot));
-}
-//# sourceMappingURL=state-io.js.map