peaks-loop 4.0.0-beta.12 → 4.0.0-beta.15

package/dist/services/mut/report-builder.d.ts

@@ -1,11 +0,0 @@
-import { type AssertionsReport, type MutationReport, type MutReportJson } from './types.js';
-import { type Thresholds } from './thresholds.js';
-export interface BuildMutInput {
-    readonly mutation: MutationReport;
-    readonly assertions: AssertionsReport;
-    readonly inputSig: string;
-    readonly out: string;
-    readonly thresholds?: Thresholds;
-    readonly now?: () => Date;
-}
-export declare function buildMutReport(input: BuildMutInput): Promise<MutReportJson>;

package/dist/services/mut/report-builder.js

@@ -1,110 +0,0 @@
-/**
- * Combines MutationReport + AssertionsReport into MutReportJson, computes
- * thresholds, derives followups, computes MUT.sig, writes file atomically.
- *
- * Hard constraints:
- *   H8 (audit trail hashable): MUT.sig is sha256 of normalized content;
- *       generatedAt + sha256 are excluded from the digest to make the
- *       signature deterministic across runs.
- *   H6 (CLI裁决): passed boolean + followups computed by CLI, not LLM.
- *   KISS: keep composition narrow — input, thresholds, output file path.
- */
-import { createHash } from 'node:crypto';
-import { mkdir, rename, unlink, writeFile } from 'node:fs/promises';
-import { dirname } from 'node:path';
-import { MutReportSchema, } from './types.js';
-import { DEFAULT_THRESHOLDS, evaluateThresholds, } from './thresholds.js';
-function deriveFollowups(m, a, t) {
-    const out = [];
-    if (m.killRate < t.mutationKillRateMin) {
-        for (const f of m.byFile) {
-            if (f.killRate < t.mutationKillRateMin) {
-                out.push({
-                    file: f.file,
-                    issue: 'low_kill_rate',
-                    severity: 'soft',
-                    suggestion: `Add tests for ${f.survived.length} survived mutants in ${f.file}`,
-                });
-            }
-        }
-    }
-    if (a.weakRate > t.weakAssertionRateMax) {
-        for (const p of a.weakPatterns) {
-            if (p.count > 0) {
-                const exampleFile = p.examples[0]?.file ?? '<unknown>';
-                out.push({
-                    file: exampleFile,
-                    issue: 'high_weak_assertions',
-                    severity: 'hard',
-                    suggestion: `Replace ${p.count} weak assertions of type "${p.pattern}" with concrete value checks`,
-                });
-            }
-        }
-    }
-    return out;
-}
-/**
- * Recursively sort object keys to produce a canonical JSON string.
- * Arrays preserve order; only object keys are sorted.
- */
-function canonicalize(value) {
-    if (value === null || typeof value !== 'object') {
-        return value;
-    }
-    if (Array.isArray(value)) {
-        return value.map((v) => canonicalize(v));
-    }
-    const obj = value;
-    const sorted = {};
-    for (const key of Object.keys(obj).sort()) {
-        sorted[key] = canonicalize(obj[key]);
-    }
-    return sorted;
-}
-function sha256OfCanonical(value) {
-    const canonical = JSON.stringify(canonicalize(value));
-    return createHash('sha256').update(canonical).digest('hex');
-}
-/**
- * Compute MUT.sig: sha256 of the report content excluding generatedAt and
- * sha256 itself. Both fields are removed before canonicalization so the
- * digest is stable across runs that differ only in timestamp.
- */
-function computeMutSig(report) {
-    const { generatedAt: _g, ...rest } = report;
-    void _g;
-    return sha256OfCanonical(rest);
-}
-export async function buildMutReport(input) {
-    const thresholds = input.thresholds ?? DEFAULT_THRESHOLDS;
-    const now = input.now ?? (() => new Date());
-    const evalResult = evaluateThresholds(thresholds, input.mutation.killRate, input.assertions.weakRate);
-    const followups = deriveFollowups(input.mutation, input.assertions, thresholds);
-    const partial = {
-        version: '1.0',
-        generatedAt: now().toISOString(),
-        inputSig: input.inputSig,
-        mutation: input.mutation,
-        assertions: input.assertions,
-        thresholds: {
-            mutationKillRateMin: thresholds.mutationKillRateMin,
-            weakAssertionRateMax: thresholds.weakAssertionRateMax,
-            passed: evalResult.passed,
-        },
-        followups,
-    };
-    const sha256 = computeMutSig(partial);
-    const final = { ...partial, sha256 };
-    MutReportSchema.parse(final);
-    await mkdir(dirname(input.out), { recursive: true });
-    const tmp = `${input.out}.tmp`;
-    try {
-        await writeFile(tmp, JSON.stringify(final, null, 2), 'utf8');
-        await rename(tmp, input.out);
-    }
-    catch (err) {
-        await unlink(tmp).catch(() => undefined);
-        throw err;
-    }
-    return final;
-}

package/dist/services/mut/report-loader.d.ts

@@ -1,31 +0,0 @@
-import { type MutReportJson } from './types.js';
-export declare const MUT_REPORT_RELATIVE_PATH = "mut/mut-report.json";
-/**
- * Build the canonical absolute path of a session's mut-report.json.
- * Exported so the CLI surface in qa-commands can reuse the same
- * constant for diagnostic messages.
- *
- * Uses POSIX separators intentionally: the one-axis envelope is
- * documented as `.peaks/_runtime/<sid>/mut/mut-report.json` (forward
- * slashes) and that path is what the hotfix 81f00ce audit-trail
- * contract guarantees. `node:path` would produce backslashes on
- * Windows, breaking the cross-platform invariant. POSIX join is
- * correct here because the result is a logical path stored in JSON
- * artifacts and CLI diagnostics — it never gets passed to OS
- * syscalls directly (readFile / writeFile accept both forms).
- */
-export declare function mutReportPath(sessionId: string): string;
-/**
- * Read and validate a session's mut-report.json.
- *
- * Returns `null` for any of these cases:
- *   - file does not exist (ENOENT)
- *   - file exists but JSON is malformed
- *   - file exists and parses but does not satisfy `MutReportSchema`
- *
- * Never throws. Never logs to stdout (per "no console.log in src/").
- * Schema-parse failures are reported via `process.stderr` so the
- * qa-runner operator can see why their report is being treated as
- * absent.
- */
-export declare function loadMutReport(sessionId: string): Promise<MutReportJson | null>;

package/dist/services/mut/report-loader.js

@@ -1,78 +0,0 @@
-/**
- * Plan 2 — Task 8: peaks-qa consumes MUT.sig from peaks-mut.
- *
- * `loadMutReport` is the read-side counterpart of `buildMutReport`
- * (which is the write-side). Both share the canonical path:
- * `.peaks/_runtime/<sessionId>/mut/mut-report.json` (per hotfix 81f00ce
- * one-axis envelope — no `.peaks/_runtime/<sessionId>/` fallback).
- *
- * Design contract (per spec lines 1292-1341):
- *   - Missing file      → `null` (gate is skipped, NOT failed)
- *   - Schema-invalid    → `null` (log via stderr; do not throw — qa is a
- *                         pre-step, not a precondition)
- *   - Schema-valid      → the parsed `MutReportJson`
- *
- * Returning `null` instead of throwing is what lets peaks-qa treat
- * "peaks mut was not run" as a no-op. If we threw, the qa gate would
- * crash on every session that hasn't run peaks-mut yet.
- */
-import { readFile } from 'node:fs/promises';
-import { posix as pathPosix } from 'node:path';
-import { MutReportSchema } from './types.js';
-export const MUT_REPORT_RELATIVE_PATH = 'mut/mut-report.json';
-/**
- * Build the canonical absolute path of a session's mut-report.json.
- * Exported so the CLI surface in qa-commands can reuse the same
- * constant for diagnostic messages.
- *
- * Uses POSIX separators intentionally: the one-axis envelope is
- * documented as `.peaks/_runtime/<sid>/mut/mut-report.json` (forward
- * slashes) and that path is what the hotfix 81f00ce audit-trail
- * contract guarantees. `node:path` would produce backslashes on
- * Windows, breaking the cross-platform invariant. POSIX join is
- * correct here because the result is a logical path stored in JSON
- * artifacts and CLI diagnostics — it never gets passed to OS
- * syscalls directly (readFile / writeFile accept both forms).
- */
-export function mutReportPath(sessionId) {
-    return pathPosix.join('.peaks', '_runtime', sessionId, MUT_REPORT_RELATIVE_PATH);
-}
-/**
- * Read and validate a session's mut-report.json.
- *
- * Returns `null` for any of these cases:
- *   - file does not exist (ENOENT)
- *   - file exists but JSON is malformed
- *   - file exists and parses but does not satisfy `MutReportSchema`
- *
- * Never throws. Never logs to stdout (per "no console.log in src/").
- * Schema-parse failures are reported via `process.stderr` so the
- * qa-runner operator can see why their report is being treated as
- * absent.
- */
-export async function loadMutReport(sessionId) {
-    const path = mutReportPath(sessionId);
-    let raw;
-    try {
-        raw = await readFile(path, 'utf8');
-    }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-        // ENOENT or permission denied — both treated as "not run".
-        return null;
-    }
-    let parsedJson;
-    try {
-        parsedJson = JSON.parse(raw);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`[peaks-qa] mut-report at ${path} is not valid JSON; treating as absent: ${message}\n`);
-        return null;
-    }
-    const parsed = MutReportSchema.safeParse(parsedJson);
-    if (!parsed.success) {
-        process.stderr.write(`[peaks-qa] mut-report at ${path} failed schema validation; treating as absent: ${parsed.error.message}\n`);
-        return null;
-    }
-    return parsed.data;
-}

package/dist/services/mut/thresholds.d.ts

@@ -1,21 +0,0 @@
-/**
- * Per spec §4.2 验收审计 — Default thresholds + evaluator.
- *
- * Override via `peaks-mut.config.json` at project root.
- */
-export interface Thresholds {
-    readonly mutationKillRateMin: number;
-    readonly weakAssertionRateMax: number;
-}
-export declare const DEFAULT_THRESHOLDS: Thresholds;
-export type ThresholdViolationKind = 'mutationKillRateMin' | 'weakAssertionRateMax';
-export interface ThresholdViolation {
-    readonly kind: ThresholdViolationKind;
-    readonly actual: number;
-    readonly threshold: number;
-}
-export interface ThresholdEvaluation {
-    readonly passed: boolean;
-    readonly violations: ReadonlyArray<ThresholdViolation>;
-}
-export declare function evaluateThresholds(t: Thresholds, actualKillRate: number, actualWeakRate: number): ThresholdEvaluation;

package/dist/services/mut/thresholds.js

@@ -1,22 +0,0 @@
-export const DEFAULT_THRESHOLDS = Object.freeze({
-    mutationKillRateMin: 0.80,
-    weakAssertionRateMax: 0.05,
-});
-export function evaluateThresholds(t, actualKillRate, actualWeakRate) {
-    const violations = [];
-    if (actualKillRate < t.mutationKillRateMin) {
-        violations.push({
-            kind: 'mutationKillRateMin',
-            actual: actualKillRate,
-            threshold: t.mutationKillRateMin,
-        });
-    }
-    if (actualWeakRate > t.weakAssertionRateMax) {
-        violations.push({
-            kind: 'weakAssertionRateMax',
-            actual: actualWeakRate,
-            threshold: t.weakAssertionRateMax,
-        });
-    }
-    return { passed: violations.length === 0, violations };
-}

package/dist/services/mut/types.d.ts

@@ -1,336 +0,0 @@
-/**
- * Per spec §4.2 验收审计 + §7 阶段二 — MutReportJson v1.0.
- *
- * Hard constraints:
- *   H8 (audit trail hashable): sha256 + inputSig (chain to TACT.sig)
- *   H6 (CLI裁决, not LLM): passed boolean is computed by CLI, not LLM
- */
-import { z } from 'zod';
-export type MutVersion = '1.0';
-export type MutTool = 'stryker' | 'mutmut' | 'go-mutesting';
-export type WeakPattern = 'toBeDefined' | 'toBeTruthy' | 'toEqual-self' | 'expect-anything' | 'toBe-self';
-export interface SurvivedMutant {
-    readonly line: number;
-    readonly mutation: string;
-    readonly survivedBecause: string;
-}
-export interface FileMutationReport {
-    readonly file: string;
-    readonly killRate: number;
-    readonly survived: ReadonlyArray<SurvivedMutant>;
-}
-export interface MutationReport {
-    readonly tool: MutTool;
-    readonly mutantsTotal: number;
-    readonly mutantsKilled: number;
-    readonly mutantsSurvived: number;
-    readonly mutantsTimeout: number;
-    readonly killRate: number;
-    readonly byFile: ReadonlyArray<FileMutationReport>;
-}
-export interface WeakExample {
-    readonly file: string;
-    readonly line: number;
-    readonly code: string;
-}
-export interface WeakPatternCount {
-    readonly pattern: WeakPattern;
-    readonly count: number;
-    readonly examples: ReadonlyArray<WeakExample>;
-}
-export interface AssertionsReport {
-    readonly totalAssertions: number;
-    readonly weakAssertions: number;
-    readonly weakRate: number;
-    readonly weakPatterns: ReadonlyArray<WeakPatternCount>;
-}
-export interface ThresholdsConfig {
-    readonly mutationKillRateMin: number;
-    readonly weakAssertionRateMax: number;
-    readonly passed: boolean;
-}
-export type FollowupSeverity = 'soft' | 'hard';
-export type FollowupIssue = 'low_kill_rate' | 'high_weak_assertions';
-export interface Followup {
-    readonly file: string;
-    readonly issue: FollowupIssue;
-    readonly severity: FollowupSeverity;
-    readonly suggestion: string;
-}
-export interface MutReportJson {
-    readonly version: MutVersion;
-    readonly sha256: string;
-    readonly generatedAt: string;
-    readonly inputSig: string;
-    readonly mutation: MutationReport;
-    readonly assertions: AssertionsReport;
-    readonly thresholds: ThresholdsConfig;
-    readonly followups: ReadonlyArray<Followup>;
-}
-export declare const WeakPatternSchema: z.ZodEnum<["toBeDefined", "toBeTruthy", "toEqual-self", "expect-anything", "toBe-self"]>;
-export declare const MutReportSchema: z.ZodObject<{
-    version: z.ZodLiteral<"1.0">;
-    sha256: z.ZodString;
-    generatedAt: z.ZodString;
-    inputSig: z.ZodString;
-    mutation: z.ZodObject<{
-        tool: z.ZodEnum<["stryker", "mutmut", "go-mutesting"]>;
-        mutantsTotal: z.ZodNumber;
-        mutantsKilled: z.ZodNumber;
-        mutantsSurvived: z.ZodNumber;
-        mutantsTimeout: z.ZodNumber;
-        killRate: z.ZodNumber;
-        byFile: z.ZodArray<z.ZodObject<{
-            file: z.ZodString;
-            killRate: z.ZodNumber;
-            survived: z.ZodArray<z.ZodObject<{
-                line: z.ZodNumber;
-                mutation: z.ZodString;
-                survivedBecause: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                line: number;
-                mutation: string;
-                survivedBecause: string;
-            }, {
-                line: number;
-                mutation: string;
-                survivedBecause: string;
-            }>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            file: string;
-            killRate: number;
-            survived: {
-                line: number;
-                mutation: string;
-                survivedBecause: string;
-            }[];
-        }, {
-            file: string;
-            killRate: number;
-            survived: {
-                line: number;
-                mutation: string;
-                survivedBecause: string;
-            }[];
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        tool: "stryker" | "mutmut" | "go-mutesting";
-        killRate: number;
-        mutantsTotal: number;
-        mutantsKilled: number;
-        mutantsSurvived: number;
-        mutantsTimeout: number;
-        byFile: {
-            file: string;
-            killRate: number;
-            survived: {
-                line: number;
-                mutation: string;
-                survivedBecause: string;
-            }[];
-        }[];
-    }, {
-        tool: "stryker" | "mutmut" | "go-mutesting";
-        killRate: number;
-        mutantsTotal: number;
-        mutantsKilled: number;
-        mutantsSurvived: number;
-        mutantsTimeout: number;
-        byFile: {
-            file: string;
-            killRate: number;
-            survived: {
-                line: number;
-                mutation: string;
-                survivedBecause: string;
-            }[];
-        }[];
-    }>;
-    assertions: z.ZodObject<{
-        totalAssertions: z.ZodNumber;
-        weakAssertions: z.ZodNumber;
-        weakRate: z.ZodNumber;
-        weakPatterns: z.ZodArray<z.ZodObject<{
-            pattern: z.ZodEnum<["toBeDefined", "toBeTruthy", "toEqual-self", "expect-anything", "toBe-self"]>;
-            count: z.ZodNumber;
-            examples: z.ZodArray<z.ZodObject<{
-                file: z.ZodString;
-                line: z.ZodNumber;
-                code: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                code: string;
-                file: string;
-                line: number;
-            }, {
-                code: string;
-                file: string;
-                line: number;
-            }>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            count: number;
-            examples: {
-                code: string;
-                file: string;
-                line: number;
-            }[];
-            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
-        }, {
-            count: number;
-            examples: {
-                code: string;
-                file: string;
-                line: number;
-            }[];
-            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        weakRate: number;
-        totalAssertions: number;
-        weakAssertions: number;
-        weakPatterns: {
-            count: number;
-            examples: {
-                code: string;
-                file: string;
-                line: number;
-            }[];
-            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
-        }[];
-    }, {
-        weakRate: number;
-        totalAssertions: number;
-        weakAssertions: number;
-        weakPatterns: {
-            count: number;
-            examples: {
-                code: string;
-                file: string;
-                line: number;
-            }[];
-            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
-        }[];
-    }>;
-    thresholds: z.ZodObject<{
-        mutationKillRateMin: z.ZodNumber;
-        weakAssertionRateMax: z.ZodNumber;
-        passed: z.ZodBoolean;
-    }, "strip", z.ZodTypeAny, {
-        passed: boolean;
-        mutationKillRateMin: number;
-        weakAssertionRateMax: number;
-    }, {
-        passed: boolean;
-        mutationKillRateMin: number;
-        weakAssertionRateMax: number;
-    }>;
-    followups: z.ZodArray<z.ZodObject<{
-        file: z.ZodString;
-        issue: z.ZodEnum<["low_kill_rate", "high_weak_assertions"]>;
-        severity: z.ZodEnum<["soft", "hard"]>;
-        suggestion: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        file: string;
-        severity: "soft" | "hard";
-        issue: "low_kill_rate" | "high_weak_assertions";
-        suggestion: string;
-    }, {
-        file: string;
-        severity: "soft" | "hard";
-        issue: "low_kill_rate" | "high_weak_assertions";
-        suggestion: string;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    version: "1.0";
-    sha256: string;
-    generatedAt: string;
-    inputSig: string;
-    mutation: {
-        tool: "stryker" | "mutmut" | "go-mutesting";
-        killRate: number;
-        mutantsTotal: number;
-        mutantsKilled: number;
-        mutantsSurvived: number;
-        mutantsTimeout: number;
-        byFile: {
-            file: string;
-            killRate: number;
-            survived: {
-                line: number;
-                mutation: string;
-                survivedBecause: string;
-            }[];
-        }[];
-    };
-    assertions: {
-        weakRate: number;
-        totalAssertions: number;
-        weakAssertions: number;
-        weakPatterns: {
-            count: number;
-            examples: {
-                code: string;
-                file: string;
-                line: number;
-            }[];
-            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
-        }[];
-    };
-    thresholds: {
-        passed: boolean;
-        mutationKillRateMin: number;
-        weakAssertionRateMax: number;
-    };
-    followups: {
-        file: string;
-        severity: "soft" | "hard";
-        issue: "low_kill_rate" | "high_weak_assertions";
-        suggestion: string;
-    }[];
-}, {
-    version: "1.0";
-    sha256: string;
-    generatedAt: string;
-    inputSig: string;
-    mutation: {
-        tool: "stryker" | "mutmut" | "go-mutesting";
-        killRate: number;
-        mutantsTotal: number;
-        mutantsKilled: number;
-        mutantsSurvived: number;
-        mutantsTimeout: number;
-        byFile: {
-            file: string;
-            killRate: number;
-            survived: {
-                line: number;
-                mutation: string;
-                survivedBecause: string;
-            }[];
-        }[];
-    };
-    assertions: {
-        weakRate: number;
-        totalAssertions: number;
-        weakAssertions: number;
-        weakPatterns: {
-            count: number;
-            examples: {
-                code: string;
-                file: string;
-                line: number;
-            }[];
-            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
-        }[];
-    };
-    thresholds: {
-        passed: boolean;
-        mutationKillRateMin: number;
-        weakAssertionRateMax: number;
-    };
-    followups: {
-        file: string;
-        severity: "soft" | "hard";
-        issue: "low_kill_rate" | "high_weak_assertions";
-        suggestion: string;
-    }[];
-}>;

package/dist/services/mut/types.js

@@ -1,59 +0,0 @@
-/**
- * Per spec §4.2 验收审计 + §7 阶段二 — MutReportJson v1.0.
- *
- * Hard constraints:
- *   H8 (audit trail hashable): sha256 + inputSig (chain to TACT.sig)
- *   H6 (CLI裁决, not LLM): passed boolean is computed by CLI, not LLM
- */
-import { z } from 'zod';
-export const WeakPatternSchema = z.enum([
-    'toBeDefined', 'toBeTruthy', 'toEqual-self', 'expect-anything', 'toBe-self',
-]);
-export const MutReportSchema = z.object({
-    version: z.literal('1.0'),
-    sha256: z.string().regex(/^[a-f0-9]{64}$/),
-    generatedAt: z.string().datetime(),
-    inputSig: z.string().regex(/^[a-f0-9]{64}$/),
-    mutation: z.object({
-        tool: z.enum(['stryker', 'mutmut', 'go-mutesting']),
-        mutantsTotal: z.number().int().nonnegative(),
-        mutantsKilled: z.number().int().nonnegative(),
-        mutantsSurvived: z.number().int().nonnegative(),
-        mutantsTimeout: z.number().int().nonnegative(),
-        killRate: z.number().min(0).max(1),
-        byFile: z.array(z.object({
-            file: z.string(),
-            killRate: z.number().min(0).max(1),
-            survived: z.array(z.object({
-                line: z.number().int(),
-                mutation: z.string(),
-                survivedBecause: z.string(),
-            })),
-        })),
-    }),
-    assertions: z.object({
-        totalAssertions: z.number().int().nonnegative(),
-        weakAssertions: z.number().int().nonnegative(),
-        weakRate: z.number().min(0).max(1),
-        weakPatterns: z.array(z.object({
-            pattern: WeakPatternSchema,
-            count: z.number().int().nonnegative(),
-            examples: z.array(z.object({
-                file: z.string(),
-                line: z.number().int(),
-                code: z.string(),
-            })),
-        })),
-    }),
-    thresholds: z.object({
-        mutationKillRateMin: z.number().min(0).max(1),
-        weakAssertionRateMax: z.number().min(0).max(1),
-        passed: z.boolean(),
-    }),
-    followups: z.array(z.object({
-        file: z.string(),
-        issue: z.enum(['low_kill_rate', 'high_weak_assertions']),
-        severity: z.enum(['soft', 'hard']),
-        suggestion: z.string(),
-    })),
-});

package/dist/shared/fs.d.ts

@@ -1,4 +0,0 @@
-export declare function pathExists(path: string): Promise<boolean>;
-export declare function readText(path: string): Promise<string>;
-export declare function listDirectories(path: string): Promise<string[]>;
-export declare function isDirectory(path: string): Promise<boolean>;