@decohere/devkit 0.0.1-dev.119

package/types/src/cli/module.type.d.ts

@@ -0,0 +1,36 @@
+import type { ContainerBuilder } from "@decohere/core/composition";
+import type { ActionClassMap } from "./action.js";
+import type { CommandType, DecohereCommand } from "./command.js";
+export type CommandMap = Record<string, CommandType>;
+export type WorkspaceFactoryOptions = {
+    configFile?: string;
+    rootDir?: string;
+};
+export interface ApplicationModule {
+    id: string;
+    dispose?(): void;
+    asyncDispose?(): Promise<void>;
+    command: DecohereCommand;
+}
+export type ModuleConfig = {
+    actions?: ActionClassMap;
+    commands?: CommandMap;
+};
+/**
+ * Simple declaration interface for a CLI module.
+ * Extend this and implement the four abstract members.
+ */
+export declare abstract class ModuleManifest {
+    /** Unique module identifier, used as the root command name. */
+    abstract readonly id: string;
+    /** Sub-command classes this module contributes. */
+    readonly commands: CommandMap;
+    /** Action classes this module contributes. */
+    readonly actions: ActionClassMap;
+    /** The root command class for this module. */
+    abstract readonly command: CommandType;
+    /** Register infrastructure services into the DI container. */
+    registerServices(_builder: ContainerBuilder): void;
+    /** Lazily create a workspace instance. Return null if this module does not use a workspace. */
+    createWorkspace(_options: WorkspaceFactoryOptions): Promise<object | null>;
+}

package/types/src/cli/options.d.ts

@@ -0,0 +1,28 @@
+import { Option } from "commander";
+export declare class ConfigurationOption extends Option {
+    constructor(defaultValue: string);
+}
+export declare class ConfigFileOption extends Option {
+    constructor(defaultValue?: string);
+}
+export declare class LogLevelOption extends Option {
+    constructor();
+}
+export declare class EnvFileOption extends Option {
+    constructor();
+}
+export declare class EnvFileIfExistsOption extends Option {
+    constructor();
+}
+export declare class NoCleanOptions extends Option {
+    constructor(defaultValue: boolean);
+}
+export declare class NoBuildOptions extends Option {
+    constructor(defaultValue: boolean);
+}
+export declare class DryRunOption extends Option {
+    constructor(description: string, defaultValue?: boolean);
+}
+export declare class ProjectOption extends Option {
+    constructor();
+}

package/types/src/diagnostics/index.d.ts

@@ -0,0 +1 @@
+export { Trace, timed, trace } from "./trace.js";

package/types/src/diagnostics/trace.d.ts

@@ -0,0 +1,10 @@
+export declare function trace(target: object, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+/**
+ * Always-on method timing. Logs duration at `info` regardless of `FORGE_TRACE`.
+ * Use this to time a specific method without raising the process log level.
+ */
+export declare function timed(target: object, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+export declare function Trace(constructor: {
+    name: string;
+    prototype: object;
+}): void;

package/types/src/interop/docker/docker.d.ts

@@ -0,0 +1,19 @@
+import { Shell } from "../shell/shell.js";
+export type DockerBuildOptions = {
+    cwd?: string;
+    dockerfile?: string;
+    tags?: string[];
+    buildArgs?: Record<string, string>;
+    secrets?: Record<string, string>;
+    noCache?: boolean;
+    pull?: boolean;
+};
+export type DockerPushOptions = {
+    cwd?: string;
+};
+export declare class Docker extends Shell {
+    readonly name: "docker";
+    protected program: string;
+    build(contextDir: string, options?: DockerBuildOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+    push(tag: string, options?: DockerPushOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+}

package/types/src/interop/errors/interop.error.d.ts

@@ -0,0 +1,2 @@
+export declare class InteropError extends Error {
+}

package/types/src/interop/git/git.d.ts

@@ -0,0 +1,16 @@
+import { Shell } from "../shell/shell.js";
+import type { ShellResponse } from "../shell/shell.types.js";
+import type { CommitOptions, GitOptions, PushOptions, StageOptions } from "./git.types.js";
+export declare class Git extends Shell {
+    protected program: string;
+    getModifiedFiles(options?: GitOptions): Promise<string[]>;
+    getBranchName(options?: GitOptions): Promise<string>;
+    tag(tag: string, options?: GitOptions): Promise<ShellResponse>;
+    pushTag(tag: string, options?: GitOptions & {
+        remote?: string;
+    }): Promise<ShellResponse>;
+    commit(message: string, options: CommitOptions): Promise<ShellResponse>;
+    push(branch: string, options?: PushOptions): Promise<ShellResponse>;
+    pull(branch: string, options?: GitOptions): Promise<ShellResponse>;
+    stage(options: StageOptions): Promise<void>;
+}

package/types/src/interop/git/git.types.d.ts

@@ -0,0 +1,14 @@
+export type GitOptions = {
+    cwd?: string;
+};
+export type CommitOptions = {
+    files?: string[];
+    all?: boolean;
+} & GitOptions;
+export type PushOptions = {
+    setUpstream: string;
+} & GitOptions;
+export type StageOptions = {
+    files?: string[];
+    all?: string;
+};

package/types/src/interop/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./docker/docker.js";
+export * from "./git/git.js";
+export * as git from "./git/git.types.js";
+export * from "./node/node.js";
+export * from "./npm/npm.js";
+export * as npm from "./npm/npm.types.js";
+export * from "./pnpm/pnpm.js";
+export * as pnpm from "./pnpm/pnpm.types.js";
+export * from "./shell/shell.js";
+export * as shell from "./shell/shell.types.js";
+export * from "./types/detect-package-manager.js";
+export * from "./types/package-manager.js";
+export * from "./yarn/yarn.js";
+export * as yarn from "./yarn/yarn.types.js";

package/types/src/interop/node/index.d.ts

@@ -0,0 +1 @@
+export * from "./node.js";

package/types/src/interop/node/node.d.ts

@@ -0,0 +1,5 @@
+import { Shell } from "../shell/shell.js";
+export declare class Node extends Shell {
+    protected program: string;
+    runScript(script: string, ...args: string[]): Promise<unknown>;
+}

package/types/src/interop/npm/npm.d.ts

@@ -0,0 +1,29 @@
+import { Shell } from "../shell/shell.js";
+import type { PackageManager } from "../types/package-manager.js";
+import type { NpmOptions, PublishOptions, VersionOptions, VersionType } from "./npm.types.js";
+export declare class Npm extends Shell implements PackageManager {
+    readonly name: "npm";
+    protected program: string;
+    publish(directory: string, options?: PublishOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+    /**
+     * @description Runs in the directory of the package
+     * @param options
+     * @returns
+     */
+    version(versionType: VersionType, options: VersionOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+    link(directory: string, options?: NpmOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+    install(options?: NpmOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+    /**
+     * Install only `dependencies` as real folders: `--omit=dev` skips devDependencies and
+     * `--no-bin-links` skips the `.bin` symlinks, so the result holds no symlinks at all.
+     */
+    installProduction(options?: NpmOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+    syncLockFile(options?: NpmOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+    /**
+     * True when package@version exists on the registry.
+     * Uses ambient npm config (cwd `.npmrc`); do not pass tokens on argv.
+     */
+    private isPublished;
+    private createTempUserConfig;
+    private removeTempUserConfig;
+}

package/types/src/interop/npm/npm.types.d.ts

@@ -0,0 +1,24 @@
+export type NpmOptions = {
+    cwd?: string;
+};
+export type PublishOptions = {
+    dryRun?: boolean;
+    skipIfPublished?: boolean;
+    authToken?: string;
+    otp?: string;
+    provenance?: boolean;
+    /** @deprecated use channel */
+    versionType?: VersionType;
+    channel?: string;
+} & NpmOptions;
+export type VersionType = "major" | "minor" | "patch" | "prerelease";
+export declare const VersionTypes: {
+    major: "major";
+    minor: "minor";
+    patch: "patch";
+    prerelease: "prerelease";
+};
+export type VersionOptions = {
+    preid?: string;
+    noTag?: boolean;
+} & NpmOptions;

package/types/src/interop/pnpm/pnpm.d.ts

@@ -0,0 +1,9 @@
+import { Shell } from "../shell/shell.js";
+import type { PackageManager } from "../types/package-manager.js";
+import type { PnpmOptions } from "./pnpm.types.js";
+export declare class Pnpm extends Shell implements PackageManager {
+    readonly name: "pnpm";
+    protected program: string;
+    install(options?: PnpmOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+    syncLockFile(options?: PnpmOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+}

package/types/src/interop/pnpm/pnpm.types.d.ts

@@ -0,0 +1,3 @@
+export type PnpmOptions = {
+    cwd?: string;
+};

package/types/src/interop/shell/shell.argv.d.ts

@@ -0,0 +1,5 @@
+declare function fields(args: string[]): Record<string, string | boolean | string[]>;
+export declare const shellArgv: {
+    fields: typeof fields;
+};
+export {};

package/types/src/interop/shell/shell.d.ts

@@ -0,0 +1,6 @@
+import type { ShellOptions, ShellResponse } from "./shell.types.js";
+export declare abstract class Shell {
+    protected abstract program: string;
+    protected run(options: ShellOptions, ...args: string[]): Promise<ShellResponse>;
+    private parseStream;
+}

package/types/src/interop/shell/shell.types.d.ts

@@ -0,0 +1,9 @@
+export type ShellResponse = {
+    message: string;
+    data: string[];
+};
+export interface ShellOptions {
+    cwd?: string;
+    /** Spawn env. Defaults to `process.env`. Not written to logs. */
+    env?: NodeJS.ProcessEnv;
+}

package/types/src/interop/types/detect-package-manager.d.ts

@@ -0,0 +1,4 @@
+import type { PackageManager } from "./package-manager.js";
+export declare function detectPackageManager(cwd: string): PackageManager | undefined;
+export declare function packageManagerFromString(name: string): PackageManager;
+export declare function promptForPackageManager(): Promise<PackageManager>;

package/types/src/interop/types/package-manager.d.ts

@@ -0,0 +1,10 @@
+import type { ShellResponse } from "../shell/shell.types.js";
+export interface PackageManager {
+    readonly name: "npm" | "pnpm" | "yarn";
+    install(options?: {
+        cwd?: string;
+    }): Promise<ShellResponse>;
+    syncLockFile(options?: {
+        cwd?: string;
+    }): Promise<ShellResponse>;
+}

package/types/src/interop/yarn/yarn.d.ts

@@ -0,0 +1,9 @@
+import { Shell } from "../shell/shell.js";
+import type { PackageManager } from "../types/package-manager.js";
+import type { YarnOptions } from "./yarn.types.js";
+export declare class Yarn extends Shell implements PackageManager {
+    readonly name: "yarn";
+    protected program: string;
+    install(options?: YarnOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+    syncLockFile(options?: YarnOptions): Promise<import("../shell/shell.types.js").ShellResponse>;
+}

package/types/src/interop/yarn/yarn.types.d.ts

@@ -0,0 +1,3 @@
+export type YarnOptions = {
+    cwd?: string;
+};

package/types/src/io/find-directories.d.ts

@@ -0,0 +1,2 @@
+import type { Directory } from "@decohere/core/io";
+export declare function findDirectories(...pattern: string[]): Promise<Directory[]>;

package/types/src/io/find-file.d.ts

@@ -0,0 +1,9 @@
+import { FileEx } from "@decohere/core/io";
+export type FindFileOptions = {
+    cwd: string;
+    ignore?: string | string[];
+};
+export declare function findFile(pattern: string): Promise<{
+    relativePath: string;
+}>;
+export declare function findFiles(patterns: string[], options?: FindFileOptions): Promise<FileEx[]>;

package/types/src/io/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./find-directories.js";
+export * from "./find-file.js";
+export * from "./watch.js";

package/types/src/io/watch.d.ts

@@ -0,0 +1,16 @@
+import { type Watcher } from "@decohere/core/io";
+export type WatchOptions = {
+    include?: string[];
+    ignore?: string[];
+    cwd?: string;
+    ignoreInitial?: boolean;
+};
+export type WatchEventName = "add" | "change" | "addDir" | "unlink" | "unlinkDir";
+export declare const WatchEvents: {
+    add: "add";
+    change: "change";
+    addDir: "addDir";
+    unlink: "unlink";
+    unlinkDir: "unlinkDir";
+};
+export declare function watch(directory: string, options?: WatchOptions): Watcher;