freeharness 0.4.1

package/node_modules/@freeharness/sdd/dist/vendor/openspec/engine/outputs.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Checks if a path contains glob pattern characters.
+ */
+export declare function isGlobPattern(pattern: string): boolean;
+/**
+ * Resolves an artifact's `generates` value to an absolute path under the change
+ * directory, asserting the result stays confined below it.
+ */
+export declare function resolveArtifactOutputPath(changeDir: string, generates: string): string;
+/**
+ * Resolves an artifact's output path(s) to concrete files that currently exist.
+ * Returns absolute file paths. Glob matches are sorted for deterministic output.
+ */
+export declare function resolveArtifactOutputs(changeDir: string, generates: string): string[];
+/**
+ * Checks if an artifact has at least one resolved output file.
+ */
+export declare function artifactOutputExists(changeDir: string, generates: string): boolean;

package/node_modules/@freeharness/sdd/dist/vendor/openspec/engine/outputs.js

@@ -0,0 +1,138 @@
+// RECONSTRUCTED (store-free, dependency-free) from
+//   @fission-ai/openspec@1.8.0 src/core/artifact-graph/outputs.ts
+//
+// The upstream module resolves an artifact's `generates` path (a literal path
+// or a glob) to concrete files under the change directory, using `fast-glob`
+// plus a hardened directory-traversal guard. To keep this slice free of the
+// `fast-glob` dependency we reimplement the same PUBLIC surface
+// (isGlobPattern / resolveArtifactOutputPath / resolveArtifactOutputs /
+// artifactOutputExists) with a small internal glob matcher that covers the
+// patterns OpenSpec schemas actually use (`proposal.md`, `specs/**/*.md`, ...).
+// Path confinement below the change directory is preserved via
+// FileSystemUtils.assertPathWithin.
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { FileSystemUtils } from './file-system.js';
+/**
+ * Checks if a path contains glob pattern characters.
+ */
+export function isGlobPattern(pattern) {
+    return pattern.includes('*') || pattern.includes('?') || pattern.includes('[');
+}
+/**
+ * Resolves an artifact's `generates` value to an absolute path under the change
+ * directory, asserting the result stays confined below it.
+ */
+export function resolveArtifactOutputPath(changeDir, generates) {
+    const outputPath = path.join(changeDir, generates);
+    FileSystemUtils.assertPathWithin(changeDir, outputPath);
+    return outputPath;
+}
+/**
+ * Compiles a POSIX-style glob (relative, `/`-separated) into an anchored
+ * regular expression. Supports `**` (any number of path segments, including
+ * zero), `*` (any run of non-separator chars), `?` (a single non-separator
+ * char), and literal text. This is intentionally minimal: it matches the
+ * `generates` patterns OpenSpec schemas emit, not the full glob grammar.
+ */
+function globToRegExp(pattern) {
+    let re = '';
+    for (let i = 0; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (ch === '*') {
+            if (pattern[i + 1] === '*') {
+                // `**` (optionally followed by `/`) matches across path separators.
+                i++;
+                if (pattern[i + 1] === '/') {
+                    i++;
+                    re += '(?:.*/)?';
+                }
+                else {
+                    re += '.*';
+                }
+            }
+            else {
+                re += '[^/]*';
+            }
+        }
+        else if (ch === '?') {
+            re += '[^/]';
+        }
+        else if ('\\^$.|+()[]{}'.includes(ch)) {
+            re += '\\' + ch;
+        }
+        else {
+            re += ch;
+        }
+    }
+    return new RegExp('^' + re + '$');
+}
+/** Recursively lists every file below `dir`, returned as absolute paths. */
+function walkFiles(dir) {
+    const out = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            out.push(...walkFiles(full));
+        }
+        else if (entry.isFile()) {
+            out.push(full);
+        }
+        else if (entry.isSymbolicLink()) {
+            try {
+                const stat = fs.statSync(full);
+                if (stat.isFile())
+                    out.push(full);
+                else if (stat.isDirectory())
+                    out.push(...walkFiles(full));
+            }
+            catch {
+                // Broken symlink — skip.
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Resolves an artifact's output path(s) to concrete files that currently exist.
+ * Returns absolute file paths. Glob matches are sorted for deterministic output.
+ */
+export function resolveArtifactOutputs(changeDir, generates) {
+    const outputPath = resolveArtifactOutputPath(changeDir, generates);
+    if (!isGlobPattern(generates)) {
+        try {
+            return fs.statSync(outputPath).isFile() ? [outputPath] : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    const regex = globToRegExp(FileSystemUtils.toPosixPath(generates));
+    const matches = [];
+    for (const file of walkFiles(changeDir)) {
+        const rel = FileSystemUtils.toPosixPath(path.relative(changeDir, file));
+        if (!regex.test(rel))
+            continue;
+        try {
+            FileSystemUtils.assertPathWithin(changeDir, file);
+        }
+        catch {
+            continue;
+        }
+        matches.push(file);
+    }
+    return Array.from(new Set(matches)).sort();
+}
+/**
+ * Checks if an artifact has at least one resolved output file.
+ */
+export function artifactOutputExists(changeDir, generates) {
+    return resolveArtifactOutputs(changeDir, generates).length > 0;
+}

package/node_modules/@freeharness/sdd/dist/vendor/openspec/engine/resolver.d.ts

@@ -0,0 +1,82 @@
+import * as fs from 'node:fs';
+import type { SchemaYaml } from './types.js';
+/**
+ * Error thrown when loading a schema fails.
+ */
+export declare class SchemaLoadError extends Error {
+    readonly schemaPath: string;
+    readonly cause?: Error | undefined;
+    constructor(message: string, schemaPath: string, cause?: Error | undefined);
+}
+/**
+ * Gets the package's built-in schemas directory path.
+ * Uses import.meta.url to resolve relative to the current module.
+ */
+export declare function getPackageSchemasDir(): string;
+/**
+ * Gets the user's schema override directory path.
+ */
+export declare function getUserSchemasDir(): string;
+/**
+ * Gets the project-local schemas directory path.
+ * @param projectRoot - The project root directory
+ * @returns The path to the project's schemas directory
+ */
+export declare function getProjectSchemasDir(projectRoot: string): string;
+export declare function isSchemaDir(parentDir: string, entry: fs.Dirent): boolean;
+/**
+ * Resolves a schema name to its directory path.
+ *
+ * Resolution order (when projectRoot is provided):
+ * 1. Project-local: <projectRoot>/openspec/schemas/<name>/schema.yaml
+ * 2. User override: ${XDG_DATA_HOME}/openspec/schemas/<name>/schema.yaml
+ * 3. Package built-in: <package>/schemas/<name>/schema.yaml
+ *
+ * When projectRoot is not provided, only user override and package built-in are checked
+ * (backward compatible behavior).
+ *
+ * @param name - Schema name (e.g., "spec-driven")
+ * @param projectRoot - Optional project root directory for project-local schema resolution
+ * @returns The path to the schema directory, or null if not found
+ */
+export declare function getSchemaDir(name: string, projectRoot?: string): string | null;
+/**
+ * Resolves a schema name to a SchemaYaml object.
+ *
+ * Resolution order (when projectRoot is provided):
+ * 1. Project-local: <projectRoot>/openspec/schemas/<name>/schema.yaml
+ * 2. User override: ${XDG_DATA_HOME}/openspec/schemas/<name>/schema.yaml
+ * 3. Package built-in: <package>/schemas/<name>/schema.yaml
+ *
+ * When projectRoot is not provided, only user override and package built-in are checked
+ * (backward compatible behavior).
+ *
+ * @param name - Schema name (e.g., "spec-driven")
+ * @param projectRoot - Optional project root directory for project-local schema resolution
+ * @returns The resolved schema object
+ * @throws Error if schema is not found in any location
+ */
+export declare function resolveSchema(name: string, projectRoot?: string): SchemaYaml;
+/**
+ * Lists all available schema names.
+ * Combines project-local, user override, and package built-in schemas.
+ *
+ * @param projectRoot - Optional project root directory for project-local schema resolution
+ */
+export declare function listSchemas(projectRoot?: string): string[];
+/**
+ * Schema info with metadata (name, description, artifacts).
+ */
+export interface SchemaInfo {
+    name: string;
+    description: string;
+    artifacts: string[];
+    source: 'project' | 'user' | 'package';
+}
+/**
+ * Lists all available schemas with their descriptions and artifact lists.
+ * Useful for agent skills to present schema selection to users.
+ *
+ * @param projectRoot - Optional project root directory for project-local schema resolution
+ */
+export declare function listSchemasWithInfo(projectRoot?: string): SchemaInfo[];

package/node_modules/@freeharness/sdd/dist/vendor/openspec/engine/resolver.js

@@ -0,0 +1,333 @@
+// Vendored from @fission-ai/openspec@1.8.0
+//   src/core/artifact-graph/resolver.ts
+// ONLY change vs upstream: import paths rewritten so the slice resolves within
+// this vendored engine directory:
+//   ../global-config.js        -> ./global-config.js   (store-free replacement)
+//   ../../utils/file-system.js -> ./file-system.js
+// Behaviour is otherwise unchanged. Note: getPackageSchemasDir points at a
+// <package>/schemas dir that this slice does not ship; the existsSync guards in
+// resolveSchema/listSchemas make a missing package-schemas dir a no-op.
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getGlobalDataDir } from './global-config.js';
+import { FileSystemUtils } from './file-system.js';
+import { parseSchema, SchemaValidationError } from './schema.js';
+/**
+ * Error thrown when loading a schema fails.
+ */
+export class SchemaLoadError extends Error {
+    schemaPath;
+    cause;
+    constructor(message, schemaPath, cause) {
+        super(message);
+        this.schemaPath = schemaPath;
+        this.cause = cause;
+        this.name = 'SchemaLoadError';
+    }
+}
+/**
+ * Gets the package's built-in schemas directory path.
+ * Uses import.meta.url to resolve relative to the current module.
+ */
+export function getPackageSchemasDir() {
+    const currentFile = fileURLToPath(import.meta.url);
+    // Navigate from dist/core/artifact-graph/ to package root's schemas/
+    return path.join(path.dirname(currentFile), '..', '..', '..', 'schemas');
+}
+/**
+ * Gets the user's schema override directory path.
+ */
+export function getUserSchemasDir() {
+    return path.join(getGlobalDataDir(), 'schemas');
+}
+/**
+ * Gets the project-local schemas directory path.
+ * @param projectRoot - The project root directory
+ * @returns The path to the project's schemas directory
+ */
+export function getProjectSchemasDir(projectRoot) {
+    return path.join(projectRoot, 'openspec', 'schemas');
+}
+/**
+ * Determines whether a directory entry represents a schema directory candidate.
+ *
+ * Returns true for real directories and for symlinks whose target is a
+ * directory. `fs.Dirent.isDirectory()` reports the raw entry type, so a symlink
+ * (even one pointing at a directory) has `isDirectory() === false`; we
+ * dereference such entries via `fs.statSync` to admit symlinked schema dirs
+ * while still rejecting symlinks-to-files and broken/dangling symlinks.
+ *
+ * @param parentDir - The directory containing the entry
+ * @param entry - The directory entry from `fs.readdirSync(..., { withFileTypes: true })`
+ */
+/**
+ * Directories `schema fork` creates transiently while swapping a fork into
+ * place: a staging copy (`.fork-staging-<rand>`, created via mkdtemp) and a
+ * backup of the previous destination (`<name>.fork-backup-<pid>-<ts>`). Either
+ * can briefly coexist with real schemas in the schemas dir, so discovery must
+ * never surface them. Real schema names are kebab-case (no dots), so excluding
+ * these dot-bearing temp names can never hide a legitimate schema.
+ */
+function isOwnedForkTempDir(name) {
+    return name.startsWith('.fork-staging-') || name.includes('.fork-backup-');
+}
+export function isSchemaDir(parentDir, entry) {
+    if (isOwnedForkTempDir(entry.name)) {
+        return false;
+    }
+    if (entry.isDirectory()) {
+        return true;
+    }
+    if (entry.isSymbolicLink()) {
+        try {
+            // statSync follows the link; isDirectory() reflects the target type.
+            return fs.statSync(path.join(parentDir, entry.name)).isDirectory();
+        }
+        catch {
+            // Broken symlink (dangling target) — statSync throws; treat as non-dir.
+            return false;
+        }
+    }
+    return false;
+}
+/**
+ * Returns a schema directory only when its schema file stays within that
+ * directory's canonical trust boundary. The directory itself may be a symlink;
+ * external user schema links are an intentionally supported workflow.
+ */
+function getSchemaCandidateDir(schemasDir, name) {
+    const schemaDir = path.join(schemasDir, name);
+    const schemaPath = path.join(schemaDir, 'schema.yaml');
+    if (!fs.existsSync(schemaPath)) {
+        return null;
+    }
+    try {
+        FileSystemUtils.assertPathWithin(schemaDir, schemaPath);
+        return schemaDir;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolves a schema name to its directory path.
+ *
+ * Resolution order (when projectRoot is provided):
+ * 1. Project-local: <projectRoot>/openspec/schemas/<name>/schema.yaml
+ * 2. User override: ${XDG_DATA_HOME}/openspec/schemas/<name>/schema.yaml
+ * 3. Package built-in: <package>/schemas/<name>/schema.yaml
+ *
+ * When projectRoot is not provided, only user override and package built-in are checked
+ * (backward compatible behavior).
+ *
+ * @param name - Schema name (e.g., "spec-driven")
+ * @param projectRoot - Optional project root directory for project-local schema resolution
+ * @returns The path to the schema directory, or null if not found
+ */
+export function getSchemaDir(name, projectRoot) {
+    if (name.length === 0 ||
+        name === '.' ||
+        name === '..' ||
+        /[\\/]/u.test(name) ||
+        /^[A-Za-z]:/u.test(name) ||
+        path.posix.isAbsolute(name) ||
+        path.win32.isAbsolute(name)) {
+        return null;
+    }
+    // 1. Check project-local directory (if projectRoot provided)
+    if (projectRoot) {
+        const projectDir = getSchemaCandidateDir(getProjectSchemasDir(projectRoot), name);
+        if (projectDir) {
+            return projectDir;
+        }
+    }
+    // 2. Check user override directory
+    const userDir = getSchemaCandidateDir(getUserSchemasDir(), name);
+    if (userDir) {
+        return userDir;
+    }
+    // 3. Check package built-in directory
+    const packageDir = getSchemaCandidateDir(getPackageSchemasDir(), name);
+    if (packageDir) {
+        return packageDir;
+    }
+    return null;
+}
+/**
+ * Resolves a schema name to a SchemaYaml object.
+ *
+ * Resolution order (when projectRoot is provided):
+ * 1. Project-local: <projectRoot>/openspec/schemas/<name>/schema.yaml
+ * 2. User override: ${XDG_DATA_HOME}/openspec/schemas/<name>/schema.yaml
+ * 3. Package built-in: <package>/schemas/<name>/schema.yaml
+ *
+ * When projectRoot is not provided, only user override and package built-in are checked
+ * (backward compatible behavior).
+ *
+ * @param name - Schema name (e.g., "spec-driven")
+ * @param projectRoot - Optional project root directory for project-local schema resolution
+ * @returns The resolved schema object
+ * @throws Error if schema is not found in any location
+ */
+export function resolveSchema(name, projectRoot) {
+    // Normalize name (remove .yaml extension if provided)
+    const normalizedName = name.replace(/\.ya?ml$/, '');
+    const schemaDir = getSchemaDir(normalizedName, projectRoot);
+    if (!schemaDir) {
+        const availableSchemas = listSchemas(projectRoot);
+        throw new Error(`Schema '${normalizedName}' not found. Available schemas: ${availableSchemas.join(', ')}`);
+    }
+    const schemaPath = path.join(schemaDir, 'schema.yaml');
+    // Load and parse the schema
+    let content;
+    try {
+        content = fs.readFileSync(schemaPath, 'utf-8');
+    }
+    catch (err) {
+        const ioError = err instanceof Error ? err : new Error(String(err));
+        throw new SchemaLoadError(`Failed to read schema at '${schemaPath}': ${ioError.message}`, schemaPath, ioError);
+    }
+    try {
+        return parseSchema(content);
+    }
+    catch (err) {
+        if (err instanceof SchemaValidationError) {
+            throw new SchemaLoadError(`Invalid schema at '${schemaPath}': ${err.message}`, schemaPath, err);
+        }
+        const parseError = err instanceof Error ? err : new Error(String(err));
+        throw new SchemaLoadError(`Failed to parse schema at '${schemaPath}': ${parseError.message}`, schemaPath, parseError);
+    }
+}
+/**
+ * Lists all available schema names.
+ * Combines project-local, user override, and package built-in schemas.
+ *
+ * @param projectRoot - Optional project root directory for project-local schema resolution
+ */
+export function listSchemas(projectRoot) {
+    const schemas = new Set();
+    // Add package built-in schemas
+    const packageDir = getPackageSchemasDir();
+    if (fs.existsSync(packageDir)) {
+        for (const entry of fs.readdirSync(packageDir, { withFileTypes: true })) {
+            if (isSchemaDir(packageDir, entry)) {
+                const schemaPath = path.join(packageDir, entry.name, 'schema.yaml');
+                if (fs.existsSync(schemaPath)) {
+                    schemas.add(entry.name);
+                }
+            }
+        }
+    }
+    // Add user override schemas (may override package schemas)
+    const userDir = getUserSchemasDir();
+    if (fs.existsSync(userDir)) {
+        for (const entry of fs.readdirSync(userDir, { withFileTypes: true })) {
+            if (isSchemaDir(userDir, entry)) {
+                const schemaPath = path.join(userDir, entry.name, 'schema.yaml');
+                if (fs.existsSync(schemaPath)) {
+                    schemas.add(entry.name);
+                }
+            }
+        }
+    }
+    // Add project-local schemas (if projectRoot provided)
+    if (projectRoot) {
+        const projectDir = getProjectSchemasDir(projectRoot);
+        if (fs.existsSync(projectDir)) {
+            for (const entry of fs.readdirSync(projectDir, { withFileTypes: true })) {
+                if (isSchemaDir(projectDir, entry)) {
+                    const schemaPath = path.join(projectDir, entry.name, 'schema.yaml');
+                    if (fs.existsSync(schemaPath)) {
+                        schemas.add(entry.name);
+                    }
+                }
+            }
+        }
+    }
+    return Array.from(schemas).sort();
+}
+/**
+ * Lists all available schemas with their descriptions and artifact lists.
+ * Useful for agent skills to present schema selection to users.
+ *
+ * @param projectRoot - Optional project root directory for project-local schema resolution
+ */
+export function listSchemasWithInfo(projectRoot) {
+    const schemas = [];
+    const seenNames = new Set();
+    // Add project-local schemas first (highest priority, if projectRoot provided)
+    if (projectRoot) {
+        const projectDir = getProjectSchemasDir(projectRoot);
+        if (fs.existsSync(projectDir)) {
+            for (const entry of fs.readdirSync(projectDir, { withFileTypes: true })) {
+                if (isSchemaDir(projectDir, entry)) {
+                    const schemaPath = path.join(projectDir, entry.name, 'schema.yaml');
+                    if (fs.existsSync(schemaPath)) {
+                        try {
+                            const schema = parseSchema(fs.readFileSync(schemaPath, 'utf-8'));
+                            schemas.push({
+                                name: entry.name,
+                                description: schema.description || '',
+                                artifacts: schema.artifacts.map((a) => a.id),
+                                source: 'project',
+                            });
+                            seenNames.add(entry.name);
+                        }
+                        catch {
+                            // Skip invalid schemas
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Add user override schemas (if not overridden by project)
+    const userDir = getUserSchemasDir();
+    if (fs.existsSync(userDir)) {
+        for (const entry of fs.readdirSync(userDir, { withFileTypes: true })) {
+            if (isSchemaDir(userDir, entry) && !seenNames.has(entry.name)) {
+                const schemaPath = path.join(userDir, entry.name, 'schema.yaml');
+                if (fs.existsSync(schemaPath)) {
+                    try {
+                        const schema = parseSchema(fs.readFileSync(schemaPath, 'utf-8'));
+                        schemas.push({
+                            name: entry.name,
+                            description: schema.description || '',
+                            artifacts: schema.artifacts.map((a) => a.id),
+                            source: 'user',
+                        });
+                        seenNames.add(entry.name);
+                    }
+                    catch {
+                        // Skip invalid schemas
+                    }
+                }
+            }
+        }
+    }
+    // Add package built-in schemas (if not overridden by project or user)
+    const packageDir = getPackageSchemasDir();
+    if (fs.existsSync(packageDir)) {
+        for (const entry of fs.readdirSync(packageDir, { withFileTypes: true })) {
+            if (isSchemaDir(packageDir, entry) && !seenNames.has(entry.name)) {
+                const schemaPath = path.join(packageDir, entry.name, 'schema.yaml');
+                if (fs.existsSync(schemaPath)) {
+                    try {
+                        const schema = parseSchema(fs.readFileSync(schemaPath, 'utf-8'));
+                        schemas.push({
+                            name: entry.name,
+                            description: schema.description || '',
+                            artifacts: schema.artifacts.map((a) => a.id),
+                            source: 'package',
+                        });
+                    }
+                    catch {
+                        // Skip invalid schemas
+                    }
+                }
+            }
+        }
+    }
+    return schemas.sort((a, b) => a.name.localeCompare(b.name));
+}

package/node_modules/@freeharness/sdd/dist/vendor/openspec/engine/schema.d.ts

@@ -0,0 +1,12 @@
+import { type SchemaYaml } from './types.js';
+export declare class SchemaValidationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Loads and validates an artifact schema from a YAML file.
+ */
+export declare function loadSchema(filePath: string): SchemaYaml;
+/**
+ * Parses and validates an artifact schema from YAML content.
+ */
+export declare function parseSchema(yamlContent: string): SchemaYaml;