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

package/dist/core/specs-apply.js

@@ -57,7 +57,7 @@ export async function findSpecUpdates(changeDir, mainSpecsDir) {
  * Build an updated spec by applying delta operations.
  * Returns the rebuilt content and counts of operations.
  */
-export async function buildUpdatedSpec(update, changeName) {
+export async function buildUpdatedSpec(update, changeName, options = {}) {
     // Read change spec content (delta-format expected)
     const changeContent = await fs.readFile(update.source, 'utf-8');
     // Parse deltas from the change spec file
@@ -148,7 +148,7 @@ export async function buildUpdatedSpec(update, changeName) {
             throw new Error(`${specName}: target spec does not exist; only ADDED requirements are allowed for new specs. MODIFIED and RENAMED operations require an existing spec.`);
         }
         // Warn about REMOVED requirements being ignored for new specs
-        if (plan.removed.length > 0) {
+        if (plan.removed.length > 0 && !options.silent) {
             console.log(chalk.yellow(`⚠️  Warning: ${specName} - ${plan.removed.length} REMOVED requirement(s) ignored for new spec (nothing to remove).`));
         }
         isNewSpec = true;
@@ -207,7 +207,8 @@ export async function buildUpdatedSpec(update, changeName) {
     // MODIFIED
     for (const mod of plan.modified) {
         const key = normalizeRequirementName(mod.name);
-        if (!nameToBlock.has(key)) {
+        const currentBlock = nameToBlock.get(key);
+        if (!currentBlock) {
             throw new Error(`${specName} MODIFIED failed for header "### Requirement: ${mod.name}" - not found`);
         }
         // Replace block with provided raw (ensure header line matches key)
@@ -215,6 +216,10 @@ export async function buildUpdatedSpec(update, changeName) {
         if (!modHeaderMatch || normalizeRequirementName(modHeaderMatch[1]) !== key) {
             throw new Error(`${specName} MODIFIED failed for header "### Requirement: ${mod.name}" - header mismatch in content`);
         }
+        const missingScenarios = findMissingCurrentScenarios(currentBlock, mod);
+        if (missingScenarios.length > 0) {
+            throw new Error(`${specName} MODIFIED failed for header "### Requirement: ${mod.name}" - current spec contains scenario(s) not present in the modified block: ${missingScenarios.map(name => `"${name}"`).join(', ')}. Refresh the change spec before archiving to avoid dropping scenarios.`);
+        }
         nameToBlock.set(key, mod);
     }
     // ADDED
@@ -265,13 +270,15 @@ export async function buildUpdatedSpec(update, changeName) {
 /**
  * Write an updated spec to disk.
  */
-export async function writeUpdatedSpec(update, rebuilt, counts) {
+export async function writeUpdatedSpec(update, rebuilt, counts, options = {}) {
     // Create target directory if needed
     const targetDir = path.dirname(update.target);
     await fs.mkdir(targetDir, { recursive: true });
     await fs.writeFile(update.target, rebuilt);
+    if (options.silent)
+        return;
     const specName = path.basename(path.dirname(update.target));
-    console.log(`Applying changes to openspec/specs/${specName}/spec.md:`);
+    console.log(`Applying changes to ${options.displayPath ?? `openspec/specs/${specName}/spec.md`}:`);
     if (counts.added)
         console.log(`  + ${counts.added} added`);
     if (counts.modified)
@@ -288,6 +295,35 @@ export function buildSpecSkeleton(specFolderName, changeName) {
     const titleBase = specFolderName;
     return `# ${titleBase} Specification\n\n## Purpose\nTBD - created by archiving change ${changeName}. Update Purpose after archive.\n\n## Requirements\n`;
 }
+function findMissingCurrentScenarios(current, incoming) {
+    const incomingScenarioNames = new Set(parseScenarioBlocks(incoming.raw).map((scenario) => scenario.name));
+    return parseScenarioBlocks(current.raw)
+        .filter((scenario) => !incomingScenarioNames.has(scenario.name))
+        .map((scenario) => scenario.name);
+}
+function parseScenarioBlocks(requirementRaw) {
+    const lines = requirementRaw.replace(/\r\n?/g, '\n').split('\n');
+    const scenarios = [];
+    let index = 0;
+    while (index < lines.length) {
+        const headerMatch = lines[index].match(/^####\s*Scenario:\s*(.+)\s*$/);
+        if (!headerMatch) {
+            index++;
+            continue;
+        }
+        const start = index;
+        const name = headerMatch[1].trim();
+        index++;
+        while (index < lines.length && !/^####\s*Scenario:\s*(.+)\s*$/.test(lines[index])) {
+            index++;
+        }
+        scenarios.push({
+            name,
+            raw: lines.slice(start, index).join('\n').trimEnd(),
+        });
+    }
+    return scenarios;
+}
 /**
  * Apply all delta specs from a change to main specs.
  *

package/dist/core/store/errors.d.ts

@@ -0,0 +1,20 @@
+export type StoreDiagnosticSeverity = 'error' | 'warning' | 'info';
+export interface StoreDiagnostic {
+    severity: StoreDiagnosticSeverity;
+    code: string;
+    message: string;
+    target?: string;
+    fix?: string;
+}
+export declare class StoreError extends Error {
+    readonly diagnostic: StoreDiagnostic;
+    constructor(message: string, code: string, options?: {
+        target?: string;
+        fix?: string;
+    });
+}
+export declare function makeStoreDiagnostic(severity: StoreDiagnosticSeverity, code: string, message: string, options?: {
+    target?: string;
+    fix?: string;
+}): StoreDiagnostic;
+//# sourceMappingURL=errors.d.ts.map

package/dist/core/{context-store → store}/errors.js

@@ -1,8 +1,8 @@
-export class ContextStoreError extends Error {
+export class StoreError extends Error {
     diagnostic;
     constructor(message, code, options = {}) {
         super(message);
-        this.name = 'ContextStoreError';
+        this.name = 'StoreError';
         this.diagnostic = {
             severity: 'error',
             code,
@@ -11,7 +11,7 @@ export class ContextStoreError extends Error {
         };
     }
 }
-export function makeContextStoreDiagnostic(severity, code, message, options = {}) {
+export function makeStoreDiagnostic(severity, code, message, options = {}) {
     return {
         severity,
         code,

package/dist/core/store/foundation.d.ts

@@ -0,0 +1,56 @@
+export declare const STORE_METADATA_DIR_NAME = ".openspec-store";
+export declare const STORE_METADATA_FILE_NAME = "store.yaml";
+export declare const STORES_DIR_NAME = "stores";
+export declare const STORE_REGISTRY_FILE_NAME = "registry.yaml";
+export interface StorePathOptions {
+    globalDataDir?: string;
+}
+export interface StoreGitBackendConfig {
+    type: 'git';
+    local_path: string;
+    remote?: string;
+    branch?: string;
+}
+export type StoreBackendConfig = StoreGitBackendConfig;
+export interface StoreRegistryEntryState {
+    backend: StoreBackendConfig;
+}
+export interface StoreRegistryState {
+    version: 1;
+    stores: Record<string, StoreRegistryEntryState>;
+}
+export interface StoreRegistryEntry {
+    id: string;
+    backend: StoreBackendConfig;
+}
+export interface StoreMetadataState {
+    version: 1;
+    id: string;
+    /** Canonical clone source, team-authored. Optional (slice 3.3). */
+    remote?: string;
+}
+export interface ResolveGitStoreBackendInput {
+    localPath: string;
+    remote?: string;
+    branch?: string;
+}
+export declare function getStoresDir(options?: StorePathOptions): string;
+export declare function getStoreRegistryPath(options?: StorePathOptions): string;
+export declare function getStoreMetadataDir(storeRoot: string): string;
+export declare function getStoreMetadataPath(storeRoot: string): string;
+export declare function validateStoreId(id: string): string;
+export declare function isValidStoreId(id: string): boolean;
+export declare function parseStoreRegistryState(content: string): StoreRegistryState;
+export declare function parseStoreMetadataState(content: string): StoreMetadataState;
+export declare function serializeStoreRegistryState(state: StoreRegistryState): string;
+export declare function serializeStoreMetadataState(state: StoreMetadataState): string;
+export declare function listStoreRegistryEntries(registry: StoreRegistryState): StoreRegistryEntry[];
+export declare function isStoreRoot(candidateRoot: string): Promise<boolean>;
+export declare function readStoreRegistryState(options?: StorePathOptions): Promise<StoreRegistryState | null>;
+export declare function writeStoreRegistryState(state: StoreRegistryState, options?: StorePathOptions): Promise<void>;
+export declare function updateStoreRegistryState(updater: (state: StoreRegistryState | null) => StoreRegistryState | Promise<StoreRegistryState>, options?: StorePathOptions): Promise<StoreRegistryState>;
+export declare function readStoreMetadataState(storeRoot: string): Promise<StoreMetadataState>;
+export declare function readOptionalStoreMetadataState(storeRoot: string): Promise<StoreMetadataState | null>;
+export declare function writeStoreMetadataState(storeRoot: string, state: StoreMetadataState): Promise<void>;
+export declare function resolveGitStoreBackendConfig(input: ResolveGitStoreBackendInput, cwd?: string): Promise<StoreGitBackendConfig>;
+//# sourceMappingURL=foundation.d.ts.map

package/dist/core/store/foundation.js

@@ -0,0 +1,251 @@
+import * as nodeFs from 'node:fs';
+import * as path from 'node:path';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import { z } from 'zod';
+import { folderStyleNameProblem, isKebabId, KEBAB_ID_DESCRIPTION, KEBAB_ID_FIX, } from '../id.js';
+import { getGlobalDataDir } from '../global-config.js';
+import { FileSystemUtils } from '../../utils/file-system.js';
+import { acquireFileLock, isNodeErrorCode, makeLockErrorFactory, pathIsDirectory, pathIsFile, releaseFileLock, writeFileAtomically, } from '../file-state.js';
+import { formatZodIssues } from '../zod-issues.js';
+import { StoreError } from './errors.js';
+const fs = nodeFs.promises;
+export const STORE_METADATA_DIR_NAME = '.openspec-store';
+export const STORE_METADATA_FILE_NAME = 'store.yaml';
+export const STORES_DIR_NAME = 'stores';
+export const STORE_REGISTRY_FILE_NAME = 'registry.yaml';
+function joinStorePath(basePath, ...segments) {
+    return FileSystemUtils.joinPath(basePath, ...segments);
+}
+export function getStoresDir(options = {}) {
+    return joinStorePath(options.globalDataDir ?? getGlobalDataDir(), STORES_DIR_NAME);
+}
+export function getStoreRegistryPath(options = {}) {
+    return joinStorePath(getStoresDir(options), STORE_REGISTRY_FILE_NAME);
+}
+export function getStoreMetadataDir(storeRoot) {
+    return joinStorePath(storeRoot, STORE_METADATA_DIR_NAME);
+}
+export function getStoreMetadataPath(storeRoot) {
+    return joinStorePath(getStoreMetadataDir(storeRoot), STORE_METADATA_FILE_NAME);
+}
+export function validateStoreId(id) {
+    const folderProblem = folderStyleNameProblem(id, 'Store id');
+    if (folderProblem !== null) {
+        throw new StoreError(folderProblem, 'invalid_store_id', {
+            target: 'store.id',
+            fix: KEBAB_ID_FIX,
+        });
+    }
+    if (!isKebabId(id)) {
+        throw new StoreError(`Store id ${KEBAB_ID_DESCRIPTION}`, 'invalid_store_id', {
+            target: 'store.id',
+            fix: KEBAB_ID_FIX,
+        });
+    }
+    return id;
+}
+export function isValidStoreId(id) {
+    try {
+        validateStoreId(id);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isFileNotFoundError(error) {
+    return isNodeErrorCode(error, 'ENOENT');
+}
+function normalizeExistingPathForStorage(existingPath) {
+    return FileSystemUtils.canonicalizeExistingPath(existingPath);
+}
+function nonEmptyOptionalString() {
+    return z.string().min(1).optional();
+}
+const GitBackendConfigSchema = z.object({
+    type: z.literal('git'),
+    local_path: z.string().min(1),
+    remote: nonEmptyOptionalString(),
+    branch: nonEmptyOptionalString(),
+}).strict();
+const RegistryEntrySchema = z.object({
+    backend: GitBackendConfigSchema,
+}).strict();
+const RegistryStateSchema = z.object({
+    version: z.literal(1),
+    stores: z.record(z.string(), RegistryEntrySchema),
+    // Legacy code-checkout map data is tolerated on read and dropped on
+    // the next write.
+    repos: z.unknown().optional(),
+}).strict();
+const MetadataStateSchema = z.object({
+    version: z.literal(1),
+    id: z.string(),
+    remote: nonEmptyOptionalString(),
+}).strict();
+function storeStateDiagnostic(label) {
+    if (label.includes('metadata')) {
+        return {
+            code: 'invalid_store_metadata',
+            target: 'store.metadata',
+            fix: 'Repair .openspec-store/store.yaml.',
+        };
+    }
+    return {
+        code: 'invalid_store_registry',
+        target: 'store.registry',
+        fix: `Repair or remove ${getStoreRegistryPath({})}.`,
+    };
+}
+function invalidStoreStateError(label, message) {
+    const diagnostic = storeStateDiagnostic(label);
+    return new StoreError(`Invalid ${label}: ${message}`, diagnostic.code, {
+        target: diagnostic.target,
+        fix: diagnostic.fix,
+    });
+}
+function parseYamlObject(content, label) {
+    try {
+        return parseYaml(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw invalidStoreStateError(label, message);
+    }
+}
+function assertValidStoreIds(ids, label) {
+    for (const id of ids) {
+        if (!isKebabId(id)) {
+            throw invalidStoreStateError(label, `'${id}': ${KEBAB_ID_DESCRIPTION}`);
+        }
+    }
+}
+export function parseStoreRegistryState(content) {
+    const raw = parseYamlObject(content, 'store registry state');
+    const result = RegistryStateSchema.safeParse(raw);
+    if (!result.success) {
+        throw invalidStoreStateError('store registry state', formatZodIssues(result.error));
+    }
+    assertValidStoreIds(Object.keys(result.data.stores), 'store id');
+    return {
+        version: 1,
+        stores: result.data.stores,
+    };
+}
+export function parseStoreMetadataState(content) {
+    const raw = parseYamlObject(content, 'store metadata state');
+    const result = MetadataStateSchema.safeParse(raw);
+    if (!result.success) {
+        throw invalidStoreStateError('store metadata state', formatZodIssues(result.error));
+    }
+    validateStoreId(result.data.id);
+    return {
+        version: 1,
+        id: result.data.id,
+        ...(result.data.remote !== undefined ? { remote: result.data.remote } : {}),
+    };
+}
+export function serializeStoreRegistryState(state) {
+    const result = RegistryStateSchema.safeParse(state);
+    if (!result.success) {
+        throw invalidStoreStateError('store registry state', formatZodIssues(result.error));
+    }
+    assertValidStoreIds(Object.keys(result.data.stores), 'store id');
+    return stringifyYaml({
+        version: 1,
+        stores: result.data.stores,
+    });
+}
+export function serializeStoreMetadataState(state) {
+    const result = MetadataStateSchema.safeParse(state);
+    if (!result.success) {
+        throw invalidStoreStateError('store metadata state', formatZodIssues(result.error));
+    }
+    validateStoreId(result.data.id);
+    return stringifyYaml({
+        version: 1,
+        id: result.data.id,
+        ...(result.data.remote !== undefined ? { remote: result.data.remote } : {}),
+    });
+}
+export function listStoreRegistryEntries(registry) {
+    return Object.entries(registry.stores)
+        .map(([id, store]) => ({ id, backend: store.backend }))
+        .sort((a, b) => a.id.localeCompare(b.id));
+}
+export async function isStoreRoot(candidateRoot) {
+    return pathIsFile(getStoreMetadataPath(candidateRoot));
+}
+export async function readStoreRegistryState(options = {}) {
+    const registryPath = getStoreRegistryPath(options);
+    if (!(await pathIsFile(registryPath))) {
+        return null;
+    }
+    return parseStoreRegistryState(await fs.readFile(registryPath, 'utf-8'));
+}
+export async function writeStoreRegistryState(state, options = {}) {
+    await writeFileAtomically(getStoreRegistryPath(options), serializeStoreRegistryState(state));
+}
+const storeRegistryLockError = makeLockErrorFactory({
+    createSubject: 'the registry lock file',
+    busyMessage: 'Store registry is busy.',
+    code: 'store_registry_busy',
+    target: 'store.registry',
+});
+export async function updateStoreRegistryState(updater, options = {}) {
+    const registryPath = getStoreRegistryPath(options);
+    const lockPath = `${registryPath}.lock`;
+    const lock = await acquireFileLock({
+        lockPath,
+        errorFor: storeRegistryLockError,
+    });
+    try {
+        const next = await updater(await readStoreRegistryState(options));
+        await writeStoreRegistryState(next, options);
+        return next;
+    }
+    finally {
+        await releaseFileLock(lock, lockPath);
+    }
+}
+export async function readStoreMetadataState(storeRoot) {
+    return parseStoreMetadataState(await fs.readFile(getStoreMetadataPath(storeRoot), 'utf-8'));
+}
+export async function readOptionalStoreMetadataState(storeRoot) {
+    try {
+        return await readStoreMetadataState(storeRoot);
+    }
+    catch (error) {
+        if (isFileNotFoundError(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function writeStoreMetadataState(storeRoot, state) {
+    await FileSystemUtils.writeFile(getStoreMetadataPath(storeRoot), serializeStoreMetadataState(state));
+}
+export async function resolveGitStoreBackendConfig(input, cwd = process.cwd()) {
+    if (input.localPath.length === 0) {
+        throw new Error('Store local path must not be empty.');
+    }
+    const resolvedPath = path.isAbsolute(input.localPath)
+        ? path.resolve(input.localPath)
+        : path.resolve(cwd, input.localPath);
+    if (!(await pathIsDirectory(resolvedPath))) {
+        throw new Error(`Store local path does not exist: ${input.localPath}`);
+    }
+    if (input.remote !== undefined && input.remote.length === 0) {
+        throw new Error('Store backend remote must not be empty when provided.');
+    }
+    if (input.branch !== undefined && input.branch.length === 0) {
+        throw new Error('Store branch must not be empty when provided.');
+    }
+    return {
+        type: 'git',
+        local_path: normalizeExistingPathForStorage(resolvedPath),
+        ...(input.remote ? { remote: input.remote } : {}),
+        ...(input.branch ? { branch: input.branch } : {}),
+    };
+}
+//# sourceMappingURL=foundation.js.map

package/dist/core/store/git.d.ts

@@ -0,0 +1,23 @@
+export declare function isGitRepositoryAtRoot(storeRoot: string): Promise<boolean>;
+export declare function initGitRepository(storeRoot: string): Promise<boolean>;
+/**
+ * `git var` resolves identity exactly as `git commit` would (config, env vars,
+ * auto-detection), so this fails precisely when the initial commit would.
+ */
+export declare function assertGitCommitIdentity(probeCwd: string): Promise<void>;
+/**
+ * Index-preserving initial commit: the pathspec on `git commit` keeps files
+ * the user had already staged out of setup's commit and leaves them staged.
+ * Pathspecs may be files or directories.
+ */
+export declare function commitStoreFiles(storeRoot: string, id: string, pathspecs: string[]): Promise<boolean>;
+export declare function gitHasCommits(storeRoot: string): Promise<boolean | null>;
+export declare function gitHasUncommittedChanges(storeRoot: string): Promise<boolean | null>;
+export declare function gitHasRemote(storeRoot: string): Promise<boolean | null>;
+/**
+ * The configured origin URL, read from local Git config only — never a
+ * network touch. Null when there is no repository or no origin.
+ */
+export declare function gitOriginUrl(storeRoot: string): Promise<string | null>;
+export declare function gitDirectoryHasTrackedFiles(storeRoot: string, relativeDir: string): Promise<boolean | null>;
+//# sourceMappingURL=git.d.ts.map

package/dist/core/store/git.js

@@ -0,0 +1,137 @@
+import { execFile } from 'node:child_process';
+import * as nodeFs from 'node:fs';
+import * as path from 'node:path';
+import { promisify } from 'node:util';
+import { StoreError } from './errors.js';
+const fs = nodeFs.promises;
+const execFileAsync = promisify(execFile);
+/**
+ * Git mechanics for stores: repository detection, setup-time init and
+ * commit, and the read-only facts doctor reports. Nothing here clones, pulls,
+ * pushes, or syncs — setup-time `git init` plus one initial commit is the
+ * entire write surface.
+ */
+function isSpawnNotFoundError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === 'ENOENT');
+}
+export async function isGitRepositoryAtRoot(storeRoot) {
+    try {
+        const stat = await fs.stat(path.join(storeRoot, '.git'));
+        return stat.isDirectory() || stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export async function initGitRepository(storeRoot) {
+    if (await isGitRepositoryAtRoot(storeRoot)) {
+        return false;
+    }
+    try {
+        await execFileAsync('git', ['init'], { cwd: storeRoot });
+    }
+    catch (error) {
+        throw new StoreError(`Failed to initialize Git repository: ${error instanceof Error ? error.message : String(error)}`, 'store_git_init_failed', {
+            target: 'store.git',
+            fix: 'Install Git or rerun setup with --no-init-git.',
+        });
+    }
+    return true;
+}
+/**
+ * `git var` resolves identity exactly as `git commit` would (config, env vars,
+ * auto-detection), so this fails precisely when the initial commit would.
+ */
+export async function assertGitCommitIdentity(probeCwd) {
+    for (const identVar of ['GIT_COMMITTER_IDENT', 'GIT_AUTHOR_IDENT']) {
+        try {
+            await execFileAsync('git', ['var', identVar], { cwd: probeCwd });
+        }
+        catch (error) {
+            if (isSpawnNotFoundError(error)) {
+                throw new StoreError('Git is not available, so setup cannot create the initial store commit.', 'store_git_init_failed', {
+                    target: 'store.git',
+                    fix: 'Install Git or rerun setup with --no-init-git.',
+                });
+            }
+            throw new StoreError('No usable Git commit identity is configured, so setup cannot create the initial store commit.', 'store_git_identity_missing', {
+                target: 'store.git',
+                fix: 'Run git config --global user.name "Your Name" and git config --global user.email "you@example.com", or rerun setup with --no-init-git.',
+            });
+        }
+    }
+}
+/**
+ * Index-preserving initial commit: the pathspec on `git commit` keeps files
+ * the user had already staged out of setup's commit and leaves them staged.
+ * Pathspecs may be files or directories.
+ */
+export async function commitStoreFiles(storeRoot, id, pathspecs) {
+    if (pathspecs.length === 0) {
+        return false;
+    }
+    try {
+        await execFileAsync('git', ['add', '--', ...pathspecs], { cwd: storeRoot });
+        await execFileAsync('git', ['commit', '-m', `Initialize OpenSpec store ${id}`, '--', ...pathspecs], { cwd: storeRoot });
+    }
+    catch (error) {
+        // Best-effort unstage so a failed commit (gpg signing, hooks) does not
+        // leave setup's files in the user's index after rollback deletes them.
+        await execFileAsync('git', ['rm', '--cached', '-r', '-f', '-q', '--', ...pathspecs], {
+            cwd: storeRoot,
+        }).catch(() => undefined);
+        throw new StoreError(`Failed to create the initial store commit: ${error instanceof Error ? error.message : String(error)}`, 'store_git_commit_failed', {
+            target: 'store.git',
+            fix: 'Commit the created files manually, or rerun setup with --no-init-git.',
+        });
+    }
+    return true;
+}
+async function gitProbe(storeRoot, args) {
+    try {
+        const { stdout } = await execFileAsync('git', ['-C', storeRoot, ...args]);
+        return stdout;
+    }
+    catch {
+        return null;
+    }
+}
+export async function gitHasCommits(storeRoot) {
+    try {
+        await execFileAsync('git', ['-C', storeRoot, 'rev-parse', '--verify', '--quiet', 'HEAD']);
+        return true;
+    }
+    catch (error) {
+        if (isSpawnNotFoundError(error))
+            return null;
+        // Exit 1 = repo exists but HEAD has no commits. Anything else (exit 128:
+        // corrupt or fake .git) is unknown, not "commitless".
+        const exitCode = error.code;
+        return exitCode === 1 ? false : null;
+    }
+}
+export async function gitHasUncommittedChanges(storeRoot) {
+    const stdout = await gitProbe(storeRoot, ['status', '--porcelain']);
+    return stdout === null ? null : stdout.trim().length > 0;
+}
+export async function gitHasRemote(storeRoot) {
+    const stdout = await gitProbe(storeRoot, ['remote']);
+    return stdout === null ? null : stdout.trim().length > 0;
+}
+/**
+ * The configured origin URL, read from local Git config only — never a
+ * network touch. Null when there is no repository or no origin.
+ */
+export async function gitOriginUrl(storeRoot) {
+    const stdout = await gitProbe(storeRoot, ['remote', 'get-url', 'origin']);
+    const url = stdout?.trim();
+    return url ? url : null;
+}
+export async function gitDirectoryHasTrackedFiles(storeRoot, relativeDir) {
+    const stdout = await gitProbe(storeRoot, ['ls-files', '--', relativeDir]);
+    return stdout === null ? null : stdout.trim().length > 0;
+}
+//# sourceMappingURL=git.js.map

package/dist/core/{context-store → store}/index.d.ts

@@ -1,6 +1,5 @@
 export * from './foundation.js';
 export * from './errors.js';
 export * from './registry.js';
-export * from './binding.js';
 export * from './operations.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/{context-store → store}/index.js

@@ -1,6 +1,5 @@
 export * from './foundation.js';
 export * from './errors.js';
 export * from './registry.js';
-export * from './binding.js';
 export * from './operations.js';
 //# sourceMappingURL=index.js.map