@oscharko-dev/keiko 0.1.5 → 0.1.7

package/dist/workspace/discovery.js

@@ -1,167 +1,2 @@
-// Recursive, bounded, deterministic file discovery and a single boundary-checked read path.
-// Security invariants (ADR-0005 D2/D3):
-//   - every directory descent and every read goes through resolveWithinWorkspace first;
-//   - always-on DENY patterns are applied before the optional .gitignore subset;
-//   - a symlink whose realpath escapes the root is skipped (never followed);
-//   - recursion is capped by maxDepth and total results by maxFiles.
-import { relative } from "node:path";
-import { nodeWorkspaceFs, } from "./fs.js";
-import { compileIgnore, isDenied, isIgnored } from "./ignore.js";
-import { resolveWithinWorkspace } from "./paths.js";
-import { assertContainedRealPath } from "./realpath.js";
-import { FileTooLargeError, PathDeniedError, WorkspaceReadError } from "./errors.js";
-import { redact } from "../gateway/redaction.js";
-import { DEFAULT_READ_OPTIONS, } from "./types.js";
-function toRelative(root, absolutePath) {
-    return relative(root, absolutePath).split("\\").join("/");
-}
-function toRealRelative(fs, root, absolutePath) {
-    try {
-        return toRelative(fs.realPath(root), absolutePath);
-    }
-    catch {
-        return toRelative(root, absolutePath);
-    }
-}
-// Returns false when the entry must be skipped for any security or noise reason, recording
-// which tier rejected it for the discovery stats.
-function isAllowed(walk, relPath, isDir) {
-    if (isDenied(relPath)) {
-        walk.denied += 1;
-        return false;
-    }
-    if (walk.applyGitignore && isIgnored(walk.matcher, relPath, isDir)) {
-        walk.ignored += 1;
-        return false;
-    }
-    return true;
-}
-function childRelative(root, absoluteDir, name) {
-    const dirRel = toRelative(root, absoluteDir);
-    return dirRel === "" ? name : `${dirRel}/${name}`;
-}
-function readDirSafe(walk, absoluteDir) {
-    try {
-        return walk.fs.readDir(absoluteDir);
-    }
-    catch {
-        return [];
-    }
-}
-function statSize(walk, absolutePath) {
-    try {
-        return walk.fs.stat(absolutePath).size;
-    }
-    catch {
-        return 0;
-    }
-}
-function handleEntry(walk, absoluteDir, entry, depth) {
-    const childAbs = resolveWithinWorkspace(walk.root, childRelative(walk.root, absoluteDir, entry.name));
-    const relPath = toRelative(walk.root, childAbs);
-    if (!isAllowed(walk, relPath, entry.isDirectory)) {
-        return;
-    }
-    // Symlinks are skipped unconditionally (for safety/simplicity). A non-symlink entry that
-    // reports neither isFile nor isDirectory is likewise treated as non-traversable noise.
-    // Only genuine files and directories are walked.
-    if (entry.isSymbolicLink) {
-        return;
-    }
-    if (entry.isDirectory) {
-        descend(walk, childAbs, depth + 1);
-        return;
-    }
-    if (entry.isFile) {
-        walk.out.push({ relativePath: relPath, sizeBytes: statSize(walk, childAbs) });
-    }
-}
-function descend(walk, absoluteDir, depth) {
-    if (depth > walk.opts.maxDepth || walk.out.length >= walk.opts.maxFiles) {
-        return;
-    }
-    const entries = [...readDirSafe(walk, absoluteDir)].sort((a, b) => (a.name < b.name ? -1 : 1));
-    for (const entry of entries) {
-        if (walk.out.length >= walk.opts.maxFiles) {
-            return;
-        }
-        handleEntry(walk, absoluteDir, entry, depth);
-    }
-}
-function runWalk(workspace, opts, fs) {
-    const walk = {
-        fs,
-        root: workspace.root,
-        matcher: compileIgnore(workspace.ignoreLines),
-        opts,
-        applyGitignore: opts.applyGitignore,
-        out: [],
-        denied: 0,
-        ignored: 0,
-    };
-    descend(walk, resolveWithinWorkspace(workspace.root, "."), 0);
-    return walk;
-}
-export function discoverFiles(workspace, opts, fs = nodeWorkspaceFs) {
-    return runWalk(workspace, opts, fs).out;
-}
-export function discoverWithStats(workspace, opts, fs = nodeWorkspaceFs) {
-    const walk = runWalk(workspace, opts, fs);
-    return {
-        files: walk.out,
-        stats: { discovered: walk.out.length, denied: walk.denied, ignored: walk.ignored },
-    };
-}
-function describe(error) {
-    return error instanceof Error ? error.message : "unknown error";
-}
-function statFile(fs, absolutePath, relPath) {
-    try {
-        return fs.stat(absolutePath);
-    }
-    catch (error) {
-        throw new WorkspaceReadError(`cannot stat file: ${relPath} (${describe(error)})`, relPath);
-    }
-}
-function assertNoHardLinkAlias(stats, relPath) {
-    if (stats.hardLinkCount !== undefined && stats.hardLinkCount > 1) {
-        throw new PathDeniedError(`refusing to read a hard-linked workspace alias: ${relPath}`, relPath);
-    }
-}
-function readContent(fs, absolutePath, relPath, opts) {
-    let raw;
-    try {
-        raw = fs.readFileUtf8(absolutePath);
-    }
-    catch (error) {
-        throw new WorkspaceReadError(`cannot read file: ${relPath} (${describe(error)})`, relPath);
-    }
-    const rawBytes = Buffer.byteLength(raw, "utf8");
-    const truncated = rawBytes > opts.maxBytes;
-    const text = truncated
-        ? Buffer.from(raw, "utf8").subarray(0, opts.maxBytes).toString("utf8")
-        : raw;
-    return { relativePath: relPath, sizeBytes: rawBytes, text: redact(text), truncated };
-}
-// The single read path. Order: boundary -> deny -> realpath containment -> size cap -> read -> redact.
-// Realpath containment is shared with the write/cwd paths via assertContainedRealPath: when the
-// path does not exist, it validates the nearest existing parent and returns absolutePath, so a
-// missing in-root file still surfaces as a WorkspaceReadError (not a false PathEscapeError).
-export function readWorkspaceFile(workspace, relPath, opts = DEFAULT_READ_OPTIONS, fs = nodeWorkspaceFs) {
-    const absolutePath = resolveWithinWorkspace(workspace.root, relPath);
-    const normalizedRel = toRelative(workspace.root, absolutePath);
-    if (isDenied(normalizedRel)) {
-        throw new PathDeniedError(`refusing to read a denied path: ${normalizedRel}`, normalizedRel);
-    }
-    const resolvedPath = assertContainedRealPath(fs, workspace.root, absolutePath, normalizedRel);
-    const resolvedRel = toRealRelative(fs, workspace.root, resolvedPath);
-    if (isDenied(resolvedRel)) {
-        throw new PathDeniedError(`refusing to read a denied path: ${normalizedRel}`, normalizedRel);
-    }
-    const stats = statFile(fs, resolvedPath, normalizedRel);
-    assertNoHardLinkAlias(stats, normalizedRel);
-    if (stats.size > opts.maxBytes) {
-        throw new FileTooLargeError(`file exceeds the read cap: ${normalizedRel}`, normalizedRel, stats.size, opts.maxBytes);
-    }
-    return readContent(fs, resolvedPath, normalizedRel, opts);
-}
+// Re-export shim: workspace discovery + safe-read seam now live in @oscharko-dev/keiko-workspace (issue #161).
+export { discoverFiles, discoverWithStats, readWorkspaceFile } from "@oscharko-dev/keiko-workspace";

package/dist/workspace/errors.d.ts

@@ -1,39 +1,2 @@
-export declare const WORKSPACE_CODES: {
-    readonly PATH_ESCAPE: "WORKSPACE_PATH_ESCAPE";
-    readonly PATH_DENIED: "WORKSPACE_PATH_DENIED";
-    readonly NOT_FOUND: "WORKSPACE_NOT_FOUND";
-    readonly FILE_TOO_LARGE: "WORKSPACE_FILE_TOO_LARGE";
-    readonly READ_FAILED: "WORKSPACE_READ_FAILED";
-};
-export type WorkspaceCode = (typeof WORKSPACE_CODES)[keyof typeof WORKSPACE_CODES];
-export declare abstract class WorkspaceError extends Error {
-    abstract readonly code: WorkspaceCode;
-    constructor(message: string, secrets?: readonly string[]);
-}
-export declare class PathEscapeError extends WorkspaceError {
-    readonly code: "WORKSPACE_PATH_ESCAPE";
-    readonly requestedPath: string;
-    constructor(message: string, requestedPath: string, secrets?: readonly string[]);
-}
-export declare class PathDeniedError extends WorkspaceError {
-    readonly code: "WORKSPACE_PATH_DENIED";
-    readonly requestedPath: string;
-    constructor(message: string, requestedPath: string, secrets?: readonly string[]);
-}
-export declare class WorkspaceNotFoundError extends WorkspaceError {
-    readonly code: "WORKSPACE_NOT_FOUND";
-    readonly startDir: string;
-    constructor(message: string, startDir: string, secrets?: readonly string[]);
-}
-export declare class FileTooLargeError extends WorkspaceError {
-    readonly code: "WORKSPACE_FILE_TOO_LARGE";
-    readonly requestedPath: string;
-    readonly sizeBytes: number;
-    readonly limitBytes: number;
-    constructor(message: string, requestedPath: string, sizeBytes: number, limitBytes: number, secrets?: readonly string[]);
-}
-export declare class WorkspaceReadError extends WorkspaceError {
-    readonly code: "WORKSPACE_READ_FAILED";
-    readonly requestedPath: string;
-    constructor(message: string, requestedPath: string, secrets?: readonly string[]);
-}
+export { WORKSPACE_CODES, WorkspaceError, PathEscapeError, PathDeniedError, WorkspaceNotFoundError, FileTooLargeError, WorkspaceReadError, } from "@oscharko-dev/keiko-workspace";
+export type { WorkspaceCode } from "@oscharko-dev/keiko-workspace";

package/dist/workspace/errors.js

@@ -1,66 +1,5 @@
-// Workspace error taxonomy, mirroring the gateway/harness pattern (ADR-0003, ADR-0004).
-// Errors carry a stable `code` discriminant; callers switch on `code`, never parse
-// `message`. Every message is redacted at construction so errors are always safe to log.
-import { redact } from "../gateway/redaction.js";
-export const WORKSPACE_CODES = {
-    PATH_ESCAPE: "WORKSPACE_PATH_ESCAPE",
-    PATH_DENIED: "WORKSPACE_PATH_DENIED",
-    NOT_FOUND: "WORKSPACE_NOT_FOUND",
-    FILE_TOO_LARGE: "WORKSPACE_FILE_TOO_LARGE",
-    READ_FAILED: "WORKSPACE_READ_FAILED",
-};
-export class WorkspaceError extends Error {
-    constructor(message, secrets = []) {
-        super(redact(message, secrets));
-        this.name = new.target.name;
-    }
-}
-// Raised when a candidate path escapes the workspace root (NUL, `..`, or absolute escape).
-export class PathEscapeError extends WorkspaceError {
-    code = WORKSPACE_CODES.PATH_ESCAPE;
-    requestedPath;
-    constructor(message, requestedPath, secrets = []) {
-        super(message, secrets);
-        this.requestedPath = requestedPath;
-    }
-}
-// Raised when a path matches an always-on deny pattern (secrets, deps, build, vcs).
-export class PathDeniedError extends WorkspaceError {
-    code = WORKSPACE_CODES.PATH_DENIED;
-    requestedPath;
-    constructor(message, requestedPath, secrets = []) {
-        super(message, secrets);
-        this.requestedPath = requestedPath;
-    }
-}
-// Raised when no workspace root (`.git` or `package.json`) is found above startDir.
-export class WorkspaceNotFoundError extends WorkspaceError {
-    code = WORKSPACE_CODES.NOT_FOUND;
-    startDir;
-    constructor(message, startDir, secrets = []) {
-        super(message, secrets);
-        this.startDir = startDir;
-    }
-}
-// Raised when a file exceeds the configured read size cap.
-export class FileTooLargeError extends WorkspaceError {
-    code = WORKSPACE_CODES.FILE_TOO_LARGE;
-    requestedPath;
-    sizeBytes;
-    limitBytes;
-    constructor(message, requestedPath, sizeBytes, limitBytes, secrets = []) {
-        super(message, secrets);
-        this.requestedPath = requestedPath;
-        this.sizeBytes = sizeBytes;
-        this.limitBytes = limitBytes;
-    }
-}
-// Raised for an underlying filesystem read failure at the IO boundary.
-export class WorkspaceReadError extends WorkspaceError {
-    code = WORKSPACE_CODES.READ_FAILED;
-    requestedPath;
-    constructor(message, requestedPath, secrets = []) {
-        super(message, secrets);
-        this.requestedPath = requestedPath;
-    }
-}
+// Re-export shim: the workspace error taxonomy is owned by @oscharko-dev/keiko-security and
+// re-exported through @oscharko-dev/keiko-workspace (issues #159, #161). Routing this shim
+// through keiko-workspace keeps the legacy `from "./errors.js"` import paths resolving for
+// callers that have not yet been migrated to the absolute package surface.
+export { WORKSPACE_CODES, WorkspaceError, PathEscapeError, PathDeniedError, WorkspaceNotFoundError, FileTooLargeError, WorkspaceReadError, } from "@oscharko-dev/keiko-workspace";

package/dist/workspace/fs.d.ts

@@ -1,21 +1,2 @@
-export interface WorkspaceStat {
-    readonly size: number;
-    readonly isFile: boolean;
-    readonly isDirectory: boolean;
-    readonly isSymbolicLink: boolean;
-    readonly hardLinkCount?: number | undefined;
-}
-export interface WorkspaceDirEntry {
-    readonly name: string;
-    readonly isDirectory: boolean;
-    readonly isFile: boolean;
-    readonly isSymbolicLink: boolean;
-}
-export interface WorkspaceFs {
-    readonly readFileUtf8: (absolutePath: string) => string;
-    readonly stat: (absolutePath: string) => WorkspaceStat;
-    readonly readDir: (absolutePath: string) => readonly WorkspaceDirEntry[];
-    readonly realPath: (absolutePath: string) => string;
-    readonly exists: (absolutePath: string) => boolean;
-}
-export declare const nodeWorkspaceFs: WorkspaceFs;
+export { nodeWorkspaceFs } from "@oscharko-dev/keiko-workspace/internal/fs";
+export type { WorkspaceFs, WorkspaceStat, WorkspaceDirEntry } from "@oscharko-dev/keiko-workspace";

package/dist/workspace/fs.js

@@ -1,36 +1,2 @@
-// The single filesystem boundary for the workspace layer (ADR-0005 D1). Every other module
-// depends on the `WorkspaceFs` port, never on `node:fs` directly, so discovery/detection are
-// testable with an in-memory fake and all real IO is auditable in one place. Synchronous, to
-// mirror the existing `loadConfigFromFile`/`readFileSync` usage in the gateway.
-import { lstatSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
-function isSymlink(absolutePath) {
-    return lstatSync(absolutePath, { throwIfNoEntry: false })?.isSymbolicLink() ?? false;
-}
-export const nodeWorkspaceFs = {
-    readFileUtf8: (absolutePath) => readFileSync(absolutePath, "utf8"),
-    stat: (absolutePath) => {
-        const stats = statSync(absolutePath, { throwIfNoEntry: true });
-        return {
-            size: stats.size,
-            isFile: stats.isFile(),
-            isDirectory: stats.isDirectory(),
-            isSymbolicLink: isSymlink(absolutePath),
-            hardLinkCount: stats.nlink,
-        };
-    },
-    readDir: (absolutePath) => readdirSync(absolutePath, { withFileTypes: true }).map((entry) => ({
-        name: entry.name,
-        isDirectory: entry.isDirectory(),
-        isFile: entry.isFile(),
-        isSymbolicLink: entry.isSymbolicLink(),
-    })),
-    realPath: (absolutePath) => realpathSync(absolutePath),
-    exists: (absolutePath) => {
-        try {
-            return statSync(absolutePath, { throwIfNoEntry: false }) !== undefined;
-        }
-        catch {
-            return false;
-        }
-    },
-};
+// Re-export shim: the workspace FS port now lives in @oscharko-dev/keiko-workspace (issue #161).
+export { nodeWorkspaceFs } from "@oscharko-dev/keiko-workspace/internal/fs";

package/dist/workspace/ignore.d.ts

@@ -1,14 +1,2 @@
-export declare const DEFAULT_DENY_PATTERNS: readonly string[];
-export declare function isDenied(relPath: string): boolean;
-interface IgnoreRule {
-    readonly regex: RegExp;
-    readonly dirEntryRegex: RegExp | null;
-    readonly negated: boolean;
-    readonly dirOnly: boolean;
-}
-export interface IgnoreMatcher {
-    readonly rules: readonly IgnoreRule[];
-}
-export declare function compileIgnore(lines: readonly string[]): IgnoreMatcher;
-export declare function isIgnored(matcher: IgnoreMatcher, relPath: string, isDir: boolean): boolean;
-export {};
+export { compileIgnore, DEFAULT_DENY_PATTERNS, isDenied, isIgnored, } from "@oscharko-dev/keiko-workspace";
+export type { IgnoreMatcher } from "@oscharko-dev/keiko-workspace";

package/dist/workspace/ignore.js

@@ -1,176 +1,2 @@
-// PURE filtering. Two tiers (ADR-0005 D3):
-//   1. isDenied()  — ALWAYS-ON security deny list. Enforced before every read regardless
-//      of .gitignore. Secret/dep/build/cache/vcs/log/os files are never discovered or read.
-//   2. compileIgnore()/isIgnored() — best-effort noise reduction over a DOCUMENTED, bounded
-//      .gitignore subset. Never relaxes the deny list.
-// Glob translation produces only linear regex pieces (`[^/]*`, `.*`) so there is no
-// catastrophic backtracking (no ReDoS).
-export const DEFAULT_DENY_PATTERNS = Object.freeze([
-    // secrets
-    ".env",
-    ".env.*",
-    "*.pem",
-    "*.key",
-    "id_rsa",
-    "id_ed25519",
-    "id_ecdsa",
-    "id_dsa",
-    "*.p12",
-    "*.pfx",
-    ".npmrc",
-    // deps
-    "node_modules",
-    // build
-    "dist",
-    "build",
-    "out",
-    "coverage",
-    // caches
-    ".cache",
-    ".next",
-    ".turbo",
-    // vcs
-    ".git",
-    // logs
-    "*.log",
-    // os
-    ".DS_Store",
-]);
-// Iterates from the end rather than using /\/+$/ to avoid quadratic ReDoS on
-// inputs with many consecutive trailing slashes (CodeQL js/polynomial-redos).
-function stripTrailingSlashes(value) {
-    let end = value.length;
-    while (end > 0 && value.charCodeAt(end - 1) === 47 /* "/" */) {
-        end -= 1;
-    }
-    return value.slice(0, end);
-}
-function normalize(relPath) {
-    return stripTrailingSlashes(relPath.replace(/\\/g, "/").replace(/^\.\//, ""));
-}
-function segments(relPath) {
-    return normalize(relPath)
-        .split("/")
-        .filter((part) => part.length > 0);
-}
-const EXAMPLE_ENV = ".env.example";
-// Always-on security check. Denied if ANY path segment matches a deny pattern (a denied
-// directory denies everything under it). `.env.example` is the single documented exception.
-// Matching is CASE-INSENSITIVE: on case-insensitive filesystems (macOS, Windows) `.ENV` and
-// `.env` name the same file, so a case-only variant must not bypass the deny list.
-export function isDenied(relPath) {
-    for (const part of segments(relPath)) {
-        const lower = part.toLowerCase();
-        if (lower === EXAMPLE_ENV) {
-            continue;
-        }
-        for (const matcher of PRECOMPILED_DENY_MATCHERS) {
-            if (matcher.regex.test(lower)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function globBody(glob) {
-    let body = "";
-    let i = 0;
-    while (i < glob.length) {
-        // charAt returns "" past the end; the loop bound guarantees a real char here, so there is
-        // no dead nullish fallback. charAt(i + 1)/(i + 2) safely return "" at the boundary.
-        const char = glob.charAt(i);
-        if (char === "*" && glob.charAt(i + 1) === "*") {
-            body += ".*";
-            i += glob.charAt(i + 2) === "/" ? 3 : 2;
-            continue;
-        }
-        if (char === "*") {
-            body += "[^/]*";
-        }
-        else if (char === "?") {
-            body += "[^/]";
-        }
-        else {
-            body += escapeLiteral(char);
-        }
-        i += 1;
-    }
-    return body;
-}
-function globToRegExp(glob, anchored) {
-    const prefix = anchored ? "^" : "^(?:.*/)?";
-    return new RegExp(`${prefix}${globBody(glob)}(?:/.*)?$`);
-}
-const PRECOMPILED_DENY_MATCHERS = DEFAULT_DENY_PATTERNS.map((pattern) => ({
-    regex: globToRegExp(pattern.toLowerCase(), false),
-}));
-// Matches the path that names the directory itself (no nested suffix), used so a `dir/` rule
-// can distinguish a real subdirectory from a same-named file at another depth.
-function globToDirEntryRegExp(glob, anchored) {
-    const prefix = anchored ? "^" : "^(?:.*/)?";
-    return new RegExp(`${prefix}${globBody(glob)}$`);
-}
-function escapeLiteral(char) {
-    return /[.*+?^${}()|[\]\\]/.test(char) ? `\\${char}` : char;
-}
-function stripAnchors(value, anchored, dirOnly) {
-    let core = value;
-    if (anchored) {
-        core = core.slice(1);
-    }
-    if (dirOnly) {
-        core = core.slice(0, -1);
-    }
-    return core;
-}
-function buildRule(rawLine) {
-    const line = rawLine.trim();
-    if (line.length === 0 || line.startsWith("#")) {
-        return null;
-    }
-    const negated = line.startsWith("!");
-    const afterBang = negated ? line.slice(1) : line;
-    const anchored = afterBang.startsWith("/");
-    const dirOnly = afterBang.endsWith("/");
-    const core = stripAnchors(afterBang, anchored, dirOnly);
-    if (core.length === 0) {
-        return null;
-    }
-    return {
-        regex: globToRegExp(core, anchored),
-        dirEntryRegex: dirOnly ? globToDirEntryRegExp(core, anchored) : null,
-        negated,
-        dirOnly,
-    };
-}
-export function compileIgnore(lines) {
-    const rules = [];
-    for (const line of lines) {
-        const rule = buildRule(line);
-        if (rule !== null) {
-            rules.push(rule);
-        }
-    }
-    return { rules };
-}
-export function isIgnored(matcher, relPath, isDir) {
-    const target = normalize(relPath);
-    let ignored = false;
-    for (const rule of matcher.rules) {
-        if (ruleMatches(rule, target, isDir)) {
-            ignored = !rule.negated;
-        }
-    }
-    return ignored;
-}
-// A `dir/` rule ignores either the matching directory entry itself (only when it IS a
-// directory), or any path genuinely nested under it. A same-named FILE is not ignored.
-function ruleMatches(rule, target, isDir) {
-    if (!rule.dirOnly) {
-        return rule.regex.test(target);
-    }
-    if (rule.dirEntryRegex?.test(target) === true) {
-        return isDir;
-    }
-    return rule.regex.test(target);
-}
+// Re-export shim: workspace deny/ignore rules now live in @oscharko-dev/keiko-workspace (issue #161).
+export { compileIgnore, DEFAULT_DENY_PATTERNS, isDenied, isIgnored, } from "@oscharko-dev/keiko-workspace";

package/dist/workspace/index.d.ts

@@ -1,11 +1,11 @@
-export type { AuditEntry, AuditSummary, ContextEntry, ContextEntrySummary, ContextPack, ContextPackSummary, ContextRequest, DiscoveredFile, DiscoveryOptions, DiscoveryStats, FileContent, ReadOptions, SelectionReason, TestFramework, WorkspaceInfo, WorkspaceLanguage, WorkspaceSummary, } from "./types.js";
-export { DEFAULT_CONTEXT_REQUEST, DEFAULT_DISCOVERY_OPTIONS, DEFAULT_READ_OPTIONS, SELECTION_REASON_PRIORITY, } from "./types.js";
-export { FileTooLargeError, PathDeniedError, PathEscapeError, WORKSPACE_CODES, WorkspaceError, WorkspaceNotFoundError, WorkspaceReadError, type WorkspaceCode, } from "./errors.js";
-export { type WorkspaceDirEntry, type WorkspaceFs, type WorkspaceStat } from "./fs.js";
-export { isWithinWorkspace, resolveWithinWorkspace } from "./paths.js";
-export { compileIgnore, DEFAULT_DENY_PATTERNS, isDenied, isIgnored, type IgnoreMatcher, } from "./ignore.js";
-export { detectWorkspace } from "./detect.js";
-export { discoverFiles, discoverWithStats, readWorkspaceFile, type DiscoveryResult, } from "./discovery.js";
-export { lexicalRetrievalStrategy, type RankedFile, type RetrievalStrategy } from "./retrieval.js";
-export { buildContextPack, buildContextPackFromFiles, type ContextPackDeps, } from "./contextPack.js";
-export { buildWorkspaceSummary, summarizeForAudit } from "./summary.js";
+export type { AuditEntry, AuditSummary, ContextEntry, ContextEntrySummary, ContextPack, ContextPackSummary, ContextRequest, DiscoveredFile, DiscoveryOptions, DiscoveryStats, FileContent, ReadOptions, SelectionReason, TestFramework, WorkspaceInfo, WorkspaceLanguage, WorkspaceSummary, } from "@oscharko-dev/keiko-workspace";
+export { DEFAULT_CONTEXT_REQUEST, DEFAULT_DISCOVERY_OPTIONS, DEFAULT_READ_OPTIONS, SELECTION_REASON_PRIORITY, } from "@oscharko-dev/keiko-workspace";
+export { FileTooLargeError, PathDeniedError, PathEscapeError, WORKSPACE_CODES, WorkspaceError, WorkspaceNotFoundError, WorkspaceReadError, type WorkspaceCode, } from "@oscharko-dev/keiko-workspace";
+export { type WorkspaceDirEntry, type WorkspaceFs, type WorkspaceStat, } from "@oscharko-dev/keiko-workspace";
+export { isWithinWorkspace, resolveWithinWorkspace } from "@oscharko-dev/keiko-workspace";
+export { compileIgnore, DEFAULT_DENY_PATTERNS, isDenied, isIgnored, type IgnoreMatcher, } from "@oscharko-dev/keiko-workspace";
+export { detectWorkspace } from "@oscharko-dev/keiko-workspace";
+export { discoverFiles, discoverWithStats, readWorkspaceFile, type DiscoveryResult, } from "@oscharko-dev/keiko-workspace";
+export { lexicalRetrievalStrategy, type RankedFile, type RetrievalStrategy, } from "@oscharko-dev/keiko-workspace";
+export { buildContextPack, buildContextPackFromFiles, type ContextPackDeps, } from "@oscharko-dev/keiko-workspace";
+export { buildWorkspaceSummary, summarizeForAudit } from "@oscharko-dev/keiko-workspace";

package/dist/workspace/index.js

@@ -1,13 +1,19 @@
-// Public barrel for the repository-context & workspace-access layer (ADR-0005). The only
-// file-read path exposed is the boundary-checked one; no export returns raw arbitrary file
-// content. Explicit named re-exports, `type` keyword for type-only, double quotes, `.js`.
-export { DEFAULT_CONTEXT_REQUEST, DEFAULT_DISCOVERY_OPTIONS, DEFAULT_READ_OPTIONS, SELECTION_REASON_PRIORITY, } from "./types.js";
-export { FileTooLargeError, PathDeniedError, PathEscapeError, WORKSPACE_CODES, WorkspaceError, WorkspaceNotFoundError, WorkspaceReadError, } from "./errors.js";
-export {} from "./fs.js";
-export { isWithinWorkspace, resolveWithinWorkspace } from "./paths.js";
-export { compileIgnore, DEFAULT_DENY_PATTERNS, isDenied, isIgnored, } from "./ignore.js";
-export { detectWorkspace } from "./detect.js";
-export { discoverFiles, discoverWithStats, readWorkspaceFile, } from "./discovery.js";
-export { lexicalRetrievalStrategy } from "./retrieval.js";
-export { buildContextPack, buildContextPackFromFiles, } from "./contextPack.js";
-export { buildWorkspaceSummary, summarizeForAudit } from "./summary.js";
+// Re-export shim: the workspace barrel now lives in @oscharko-dev/keiko-workspace (issue #161,
+// ADR-0019). All existing import sites (`from "../workspace/index.js"`, etc.) keep resolving
+// unchanged via this barrel. Mirrors the contracts/security/model-gateway extraction patterns.
+export { DEFAULT_CONTEXT_REQUEST, DEFAULT_DISCOVERY_OPTIONS, DEFAULT_READ_OPTIONS, SELECTION_REASON_PRIORITY, } from "@oscharko-dev/keiko-workspace";
+export { FileTooLargeError, PathDeniedError, PathEscapeError, WORKSPACE_CODES, WorkspaceError, WorkspaceNotFoundError, WorkspaceReadError, } from "@oscharko-dev/keiko-workspace";
+export {} from "@oscharko-dev/keiko-workspace";
+export { isWithinWorkspace, resolveWithinWorkspace } from "@oscharko-dev/keiko-workspace";
+export { compileIgnore, DEFAULT_DENY_PATTERNS, isDenied, isIgnored, } from "@oscharko-dev/keiko-workspace";
+export { detectWorkspace } from "@oscharko-dev/keiko-workspace";
+export { discoverFiles, discoverWithStats, readWorkspaceFile, } from "@oscharko-dev/keiko-workspace";
+export { lexicalRetrievalStrategy, } from "@oscharko-dev/keiko-workspace";
+export { buildContextPack, buildContextPackFromFiles, } from "@oscharko-dev/keiko-workspace";
+export { buildWorkspaceSummary, summarizeForAudit } from "@oscharko-dev/keiko-workspace";
+// Note: nodeWorkspaceFs, assertContainedRealPath, and containedRealPathInfo are intentionally
+// NOT re-exported through this legacy barrel. They were never on the pre-extraction
+// `src/workspace/index.ts` surface (verified against tests/sdk/sdk.test.ts which asserts
+// `nodeWorkspaceFs` does not leak through the SDK/root barrel re-export chain). Callers
+// that need them continue to import from the per-file shims `src/workspace/fs.js` and
+// `src/workspace/realpath.js`, both of which re-export from @oscharko-dev/keiko-workspace.

package/dist/workspace/paths.d.ts

@@ -1,2 +1 @@
-export declare function resolveWithinWorkspace(root: string, candidate: string): string;
-export declare function isWithinWorkspace(root: string, candidate: string): boolean;
+export { isWithinWorkspace, resolveWithinWorkspace } from "@oscharko-dev/keiko-workspace";

package/dist/workspace/paths.js

@@ -1,38 +1,2 @@
-// PURE, security-critical lexical path containment. This module performs NO filesystem
-// access: it decides whether a candidate path lexically resolves inside a workspace root.
-// Symlink/realpath containment (which DOES touch the filesystem) is enforced separately at
-// the IO edge in discovery.ts — see ADR-0005 D2 for the split.
-import { isAbsolute, relative, resolve, sep } from "node:path";
-import { PathEscapeError } from "./errors.js";
-function hasNul(value) {
-    return value.includes("\u0000");
-}
-// Returns the normalized absolute path of `candidate` inside `root`, or throws
-// PathEscapeError. The returned value is the ONLY path that downstream IO should read, so
-// a static analyser's path sanitizer sits on this boundary.
-export function resolveWithinWorkspace(root, candidate) {
-    if (hasNul(root) || hasNul(candidate)) {
-        throw new PathEscapeError("path contains a NUL byte", candidate);
-    }
-    const absoluteRoot = resolve(root);
-    const absoluteCandidate = isAbsolute(candidate)
-        ? resolve(candidate)
-        : resolve(absoluteRoot, candidate);
-    const rel = relative(absoluteRoot, absoluteCandidate);
-    if (rel === "") {
-        return absoluteRoot;
-    }
-    if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
-        throw new PathEscapeError(`path escapes the workspace boundary: ${candidate}`, candidate);
-    }
-    return absoluteCandidate;
-}
-export function isWithinWorkspace(root, candidate) {
-    try {
-        resolveWithinWorkspace(root, candidate);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
+// Re-export shim: workspace path-containment primitives now live in @oscharko-dev/keiko-workspace (issue #161).
+export { isWithinWorkspace, resolveWithinWorkspace } from "@oscharko-dev/keiko-workspace";

package/dist/workspace/realpath.d.ts

@@ -1,7 +1 @@
-import type { WorkspaceFs } from "./fs.js";
-export interface ContainedRealPathInfo {
-    readonly path: string;
-    readonly realRelative: string;
-}
-export declare function containedRealPathInfo(fs: WorkspaceFs, root: string, absolutePath: string): ContainedRealPathInfo;
-export declare function assertContainedRealPath(fs: WorkspaceFs, root: string, absolutePath: string, _label: string): string;
+export { assertContainedRealPath, containedRealPathInfo } from "@oscharko-dev/keiko-workspace";