tegami 0.0.0

package/dist/types-DdIMewK9.d.mts

@@ -0,0 +1,283 @@
+import * as semver from "semver";
+import { SemVer } from "semver";
+import { z } from "zod";
+
+//#region src/workspace.d.ts
+/** Package discovered in the workspace. */
+declare abstract class WorkspacePackage {
+  abstract readonly name: string;
+  abstract readonly path: string;
+  abstract readonly manager: string;
+  abstract readonly version: string;
+  abstract readonly publish: boolean;
+  get distTag(): string | undefined;
+  get id(): string;
+  setVersion?(version: string): void;
+  updateDependency?(target: WorkspacePackage, version: string, context: TegamiContext): Awaitable<void>;
+  write?(): Awaitable<void>;
+  protected updateRange(context: TegamiContext, spec: DependencySpec, next: semver.SemVer): Promise<DependencySpec>;
+}
+/** Dependency graph for discovered workspace packages. */
+declare class PackageGraph {
+  private readonly byId;
+  private readonly byName;
+  constructor(packages?: WorkspacePackage[]);
+  getPackages(): WorkspacePackage[];
+  /** Get a package by exact id. */
+  get(id: string): WorkspacePackage | undefined;
+  /** Get packages by id, or every package matching a name. */
+  getByName(nameOrId: string): WorkspacePackage[];
+  /** scan package into graph, if the package id already exists, replace the existing one in graph */
+  add(pkg: WorkspacePackage): void;
+  delete(pkg: WorkspacePackage): void;
+}
+//#endregion
+//#region src/context.d.ts
+interface TegamiContext {
+  cwd: string;
+  changelogDir: string;
+  planPath: string;
+  options: TegamiOptions;
+  plugins: TegamiPlugin[];
+  graph: PackageGraph;
+  /** error if doesn't exist */
+  getRegistryClient(pkgOrId: WorkspacePackage | string): RegistryClient;
+}
+//#endregion
+//#region src/utils/semver.d.ts
+type BumpType = "major" | "minor" | "patch";
+//#endregion
+//#region src/changelog/parse.d.ts
+interface ChangelogEntry {
+  id: string;
+  /** file name like `my-change.md` */
+  filename: string;
+  subject?: string;
+  packages: Set<string>;
+  type: BumpType;
+  title: string;
+  content: string;
+}
+//#endregion
+//#region src/draft.d.ts
+/** Per-package options applied when creating publish plans. */
+interface PackageOptions {
+  /** npm dist-tag used when publishing. */
+  distTag?: string;
+  /** Set to false to keep this package out of npm publishing. */
+  publish?: boolean;
+}
+interface PackagePlan {
+  type: BumpType;
+  changelogIds: Set<string>;
+  distTag?: string;
+  publish: boolean;
+}
+declare class DraftPlan {
+  #private;
+  private readonly changelogs;
+  private readonly packages;
+  private readonly context;
+  constructor(changelogs: Map<string, ChangelogEntry>, packages: Map<string, PackagePlan>, context: TegamiContext);
+  getPackageIds(): string[];
+  getPackage(id: string): PackagePlan | undefined;
+  setPackage(id: string, plan?: Partial<PackagePlan>): void;
+  deletePackage(id: string): boolean;
+  getChangelogIds(): string[];
+  getChangelog(id: string): ChangelogEntry | undefined;
+  setChangelog(id: string, entry: ChangelogEntry): void;
+  deleteChangelog(id: string): boolean;
+  /** Write the publish plan, update package versions, and consume changelog files. */
+  createPublishPlan(): Promise<void>;
+  private assertPublishPlanFinished;
+  private applyVersionChanges;
+  private removeConsumedChangelogs;
+  private assertEditable;
+  private appendChangelog;
+  /** {@link createPublishPlan} but for `await using` syntax */
+  [Symbol.asyncDispose](): Promise<void>;
+}
+//#endregion
+//#region src/schemas.d.ts
+declare const packageManifestSchema: z.ZodObject<{
+  name: z.ZodOptional<z.ZodString>;
+  version: z.ZodOptional<z.ZodString>;
+  private: z.ZodOptional<z.ZodBoolean>;
+  publishConfig: z.ZodOptional<z.ZodObject<{
+    access: z.ZodOptional<z.ZodEnum<{
+      public: "public";
+      restricted: "restricted";
+    }>>;
+    registry: z.ZodOptional<z.ZodString>;
+    tag: z.ZodOptional<z.ZodString>;
+  }, z.core.$loose>>;
+  workspaces: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodPipe<z.ZodObject<{
+    packages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$loose>, z.ZodTransform<string[], {
+    [x: string]: unknown;
+    packages?: string[] | undefined;
+  }>>]>, z.ZodArray<z.ZodString>>>;
+  dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  peerDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  optionalDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$loose>;
+type PackageManifest = z.infer<typeof packageManifestSchema>;
+/** the persisted plan data for actual publishing */
+declare const planStoreSchema: z.ZodCodec<z.ZodString, z.ZodObject<{
+  id: z.ZodString;
+  createdAt: z.ZodISODateTime;
+  changelogs: z.ZodRecord<z.ZodString, z.ZodObject<{
+    filename: z.ZodString;
+    subject: z.ZodOptional<z.ZodString>;
+    packages: z.ZodArray<z.ZodString>;
+    type: z.ZodEnum<{
+      major: "major";
+      minor: "minor";
+      patch: "patch";
+    }>;
+    title: z.ZodString;
+    content: z.ZodString;
+  }, z.core.$strip>>;
+  packages: z.ZodRecord<z.ZodString, z.ZodObject<{
+    type: z.ZodEnum<{
+      major: "major";
+      minor: "minor";
+      patch: "patch";
+    }>;
+    changelogIds: z.ZodCodec<z.ZodArray<z.ZodString>, z.ZodSet<z.ZodString>>;
+    distTag: z.ZodOptional<z.ZodString>;
+    publish: z.ZodBoolean;
+  }, z.core.$strip>>;
+}, z.core.$strip>>;
+type PlanStore = z.output<typeof planStoreSchema>;
+//#endregion
+//#region src/publish.d.ts
+interface PublishOptions {
+  /** Validate the publish plan without publishing packages, creating tags, or running release plugins. */
+  dryRun?: boolean;
+}
+interface PublishResult {
+  /** Path to the publish plan that was executed. */
+  planPath: string;
+  state: "success" | "failed";
+  packages: PackagePublishResult[];
+  /** the persisted plan object. This is not a public API, can be changed without notice */
+  _rawPlan: PlanStore;
+}
+type PackagePublishResult = ({
+  state: "failed";
+  error?: string;
+} | {
+  state: "success";
+}) & {
+  id: string;
+  name: string;
+  version: string;
+  distTag: string | undefined; /** added by the `git` plugin */
+  gitTag?: string;
+  changelogs: ChangelogEntry[];
+};
+//#endregion
+//#region src/providers/npm.d.ts
+declare class NpmPackage extends WorkspacePackage {
+  readonly path: string;
+  readonly manifest: PackageManifest;
+  readonly manager = "npm";
+  constructor(path: string, manifest: PackageManifest);
+  get name(): string;
+  get version(): string;
+  get publish(): boolean;
+  get distTag(): string | undefined;
+  setVersion(version: string): void;
+  updateDependency(target: WorkspacePackage, version: string, context: TegamiContext): Promise<void>;
+  write(): Promise<void>;
+}
+type NpmClient = "npm" | "pnpm";
+declare class NpmRegistryClient implements RegistryClient {
+  #private;
+  private readonly cwd;
+  private readonly npmClient;
+  private readonly graph;
+  readonly id = "npm";
+  constructor(cwd: string, npmClient: NpmClient | undefined, graph: {
+    get(id: string): WorkspacePackage | undefined;
+  });
+  supports(pkg: WorkspacePackage): boolean;
+  packageVersionExists(pkg: WorkspacePackage, version: string): Promise<boolean>;
+  publish(pkg: WorkspacePackage, options?: {
+    distTag?: string;
+  }): Promise<void>;
+  publishPlanStatus(plan: PlanStore): Promise<PublishPlanStatus>;
+  private resolveClient;
+}
+declare function npm(client?: NpmClient): TegamiPlugin;
+//#endregion
+//#region src/types.d.ts
+/** Generates changelog content for a package release. */
+interface LogGenerator {
+  generate(this: TegamiContext, opts: {
+    packageName: string;
+    version: string;
+    changelogs: ChangelogEntry[];
+  }): string | Promise<string>;
+}
+interface TegamiOptions {
+  /** Workspace root. Defaults to the current working directory. */
+  cwd?: string;
+  /** Directory containing pending changelog markdown files. */
+  changelogDir?: string;
+  /** Path to the publish plan file. */
+  planPath?: string;
+  /** Changelog generator used when creating a publish plan. */
+  generator?: LogGenerator;
+  /** Per-package release and publish options keyed by package name. */
+  packages?: Record<string, PackageOptions>;
+  plugins?: TegamiPluginOption[];
+  /** Package manager command used for npm registry operations. */
+  npmClient?: NpmClient;
+}
+type TegamiPluginOption = TegamiPlugin | TegamiPluginOption[];
+interface TegamiPlugin {
+  name: string;
+  enforce?: "pre" | "default" | "post";
+  /** when Tegami initializes */
+  init?(this: TegamiContext): Awaitable<void>;
+  /** Resolve workspace packages and dependency metadata into the shared graph. */
+  resolve?(this: TegamiContext): Awaitable<void>;
+  /** Register registry clients used to handle packages for different package managers. */
+  createRegistryClient?(this: TegamiContext): Awaitable<RegistryClient | RegistryClient[] | void | undefined>;
+  /** Called after Tegami builds the initial draft plan and before it is returned. */
+  initPlan?(this: TegamiContext, plan: DraftPlan): Awaitable<DraftPlan | void | undefined>;
+  /** Called after publishing finishes. */
+  afterPublish?(this: TegamiContext & {
+    publishOptions: PublishOptions;
+  }, result: PublishResult): Awaitable<PublishResult | void | undefined>;
+  /**
+   * @param pkg - the package that referenced the dependency
+   * @param spec - the referenced dependency & its range
+   * @param target - the target version to update to
+   * @returns fallback to the default behaviour if `undefined`, otherwise replace with updated spec (can reuse the same instance, as long as a value is returned).
+   */
+  onUpdateRange?(this: TegamiContext, pkg: WorkspacePackage, spec: DependencySpec, target: SemVer): Awaitable<DependencySpec | void | undefined>;
+}
+type Awaitable<T> = T | Promise<T>;
+interface PublishPlanStatus {
+  state: "pending" | "success";
+  error?: string;
+}
+interface RegistryClient {
+  id: string;
+  supports?(pkg: WorkspacePackage): boolean;
+  packageVersionExists(pkg: WorkspacePackage, version: string): Promise<boolean>;
+  publish(pkg: WorkspacePackage, options?: {
+    distTag?: string;
+  }): Promise<void>;
+  publishPlanStatus(plan: PlanStore): Promise<PublishPlanStatus>;
+}
+interface DependencySpec {
+  name: string;
+  range: string;
+}
+//#endregion
+export { PackageOptions as _, TegamiOptions as a, PackageGraph as b, NpmClient as c, npm as d, PackagePublishResult as f, DraftPlan as g, PlanStore as h, RegistryClient as i, NpmPackage as l, PublishResult as m, LogGenerator as n, TegamiPlugin as o, PublishOptions as p, PublishPlanStatus as r, TegamiPluginOption as s, Awaitable as t, NpmRegistryClient as u, PackagePlan as v, WorkspacePackage as x, TegamiContext as y };

package/dist/workspace-B5_i21S0.mjs

@@ -0,0 +1,63 @@
+import * as semver from "semver";
+//#region src/utils/error.ts
+function isNodeError(error) {
+	return error instanceof Error && "code" in error;
+}
+//#endregion
+//#region src/workspace.ts
+/** Package discovered in the workspace. */
+var WorkspacePackage = class {
+	get distTag() {}
+	get id() {
+		return `${this.manager}:${this.name}`;
+	}
+	async updateRange(context, spec, next) {
+		for (const plugin of context.plugins) {
+			const result = await plugin.onUpdateRange?.call(context, this, spec, next);
+			if (result) return result;
+		}
+		if (!semver.validRange(spec.range)) return spec;
+		if (new semver.Range(spec.range).test(next)) return spec;
+		spec.range = next.format();
+		return spec;
+	}
+};
+/** Dependency graph for discovered workspace packages. */
+var PackageGraph = class {
+	byId = /* @__PURE__ */ new Map();
+	byName = /* @__PURE__ */ new Map();
+	constructor(packages = []) {
+		for (const pkg of packages) this.add(pkg);
+	}
+	getPackages() {
+		return Array.from(this.byId.values());
+	}
+	/** Get a package by exact id. */
+	get(id) {
+		return this.byId.get(id);
+	}
+	/** Get packages by id, or every package matching a name. */
+	getByName(nameOrId) {
+		const exact = this.byId.get(nameOrId);
+		if (exact) return [exact];
+		return this.byName.get(nameOrId) ?? [];
+	}
+	/** scan package into graph, if the package id already exists, replace the existing one in graph */
+	add(pkg) {
+		const existing = this.byId.get(pkg.id);
+		if (existing) this.delete(existing);
+		this.byId.set(pkg.id, pkg);
+		const named = this.byName.get(pkg.name);
+		if (named) named.push(pkg);
+		else this.byName.set(pkg.name, [pkg]);
+	}
+	delete(pkg) {
+		this.byId.delete(pkg.id);
+		const named = this.byName.get(pkg.name);
+		if (!named) return;
+		const index = named.findIndex((item) => item.id === pkg.id);
+		if (index !== -1) named.splice(index, 1);
+	}
+};
+//#endregion
+export { WorkspacePackage as n, isNodeError as r, PackageGraph as t };

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "tegami",
+  "version": "0.0.0",
+  "description": "Utility for package versioning & publish",
+  "license": "MIT",
+  "author": "Fuma Nama",
+  "repository": "github:fuma-nama/tegami",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./generators/simple": "./dist/generators/simple.mjs",
+    "./plugins/git": "./dist/plugins/git.mjs",
+    "./plugins/github": "./dist/plugins/github.mjs",
+    "./providers/cargo": "./dist/providers/cargo.mjs",
+    "./providers/npm": "./dist/providers/npm.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "types:check": "tsc --noEmit",
+    "build": "tsdown",
+    "dev": "tsdown --watch"
+  },
+  "dependencies": {
+    "js-yaml": "^4.2.0",
+    "mdast-util-from-markdown": "^2.0.3",
+    "mdast-util-to-markdown": "^2.1.2",
+    "package-manager-detector": "^1.6.0",
+    "semver": "^7.8.4",
+    "smol-toml": "^1.6.1",
+    "tinyexec": "^1.2.4",
+    "tinyglobby": "^0.2.17",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@repo/typescript-config": "workspace:*",
+    "@types/js-yaml": "^4.0.9",
+    "@types/mdast": "^4.0.4",
+    "@types/node": "^25.5.0",
+    "@types/semver": "^7.7.1",
+    "tsdown": "^0.22.2",
+    "typescript": "6.0.3"
+  }
+}