@omni-oss/create-jobs 0.0.1

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":""}

package/dist/create-jobs.cjs

@@ -0,0 +1 @@
+"use strict";const o=require("node:fs/promises"),c=require("@commander-js/extra-typings"),r=require("./utils-DeP5M93O.js"),l=new c.Command;l.argument("<input>","The input file to read from.").option("-o, --output <output>","The output file to write to.").action(async(n,t)=>{const u=await o.readFile(n,"utf-8"),a=JSON.parse(u),e=r.TaskResultArraySchema.safeParse(a);if(e.success){const i=e.data,s=r.createJobs(i);t.output?await o.writeFile(t.output,JSON.stringify(s,null,2)):console.log(s)}else console.error(e.error),process.exit(1)}).parseAsync();

package/dist/create-jobs.mjs

@@ -0,0 +1,15 @@
+import s from "node:fs/promises";
+import { Command as c } from "@commander-js/extra-typings";
+import { T as u, c as l } from "./utils-CSiXyoWV.mjs";
+const p = new c();
+p.argument("<input>", "The input file to read from.").option("-o, --output <output>", "The output file to write to.").action(async (r, e) => {
+  const a = await s.readFile(r, "utf-8"), i = JSON.parse(a), t = u.safeParse(i);
+  if (t.success) {
+    const n = t.data, o = l(n);
+    e.output ? await s.writeFile(
+      e.output,
+      JSON.stringify(o, null, 2)
+    ) : console.log(o);
+  } else
+    console.error(t.error), process.exit(1);
+}).parseAsync();

package/dist/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./utils-DeP5M93O.js");exports.TaskResultArraySchema=e.TaskResultArraySchema;exports.TaskResultSchema=e.TaskResultSchema;exports.createJobs=e.createJobs;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './schemas';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC"}

package/dist/index.mjs

@@ -0,0 +1,6 @@
+import { T as e, a as r, c } from "./utils-CSiXyoWV.mjs";
+export {
+  e as TaskResultArraySchema,
+  r as TaskResultSchema,
+  c as createJobs
+};

package/dist/schemas.d.ts

@@ -0,0 +1,324 @@
+import { z } from 'zod';
+/**
+ * Defines the structure for the duration object.
+ */
+declare const ElapsedSchema: z.ZodObject<{
+    secs: z.ZodNumber;
+    nanos: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Defines the metadata for the project/task details.
+ */
+declare const MetaSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodString>;
+    targets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        runner: z.ZodString;
+        build_flags: z.ZodOptional<z.ZodString>;
+        test_flags: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    release: z.ZodOptional<z.ZodObject<{
+        npm: z.ZodOptional<z.ZodBoolean>;
+        github: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Defines the details of the task that was run or skipped.
+ */
+declare const TaskSchema: z.ZodObject<{
+    task_name: z.ZodString;
+    task_command: z.ZodString;
+    project_name: z.ZodString;
+    project_dir: z.ZodString;
+    full_task_name: z.ZodString;
+    dependencies: z.ZodArray<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+    interactive: z.ZodBoolean;
+    persistent: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Schema for a task that successfully completed.
+ * Note: 'elapsed', 'exit_code', 'hash', and 'cache_hit' are required here.
+ */
+declare const CompletedTaskSchema: z.ZodObject<{
+    status: z.ZodLiteral<"completed">;
+    hash: z.ZodString;
+    task: z.ZodObject<{
+        task_name: z.ZodString;
+        task_command: z.ZodString;
+        project_name: z.ZodString;
+        project_dir: z.ZodString;
+        full_task_name: z.ZodString;
+        dependencies: z.ZodArray<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+        interactive: z.ZodBoolean;
+        persistent: z.ZodBoolean;
+    }, z.core.$strip>;
+    exit_code: z.ZodNumber;
+    elapsed: z.ZodObject<{
+        secs: z.ZodNumber;
+        nanos: z.ZodNumber;
+    }, z.core.$strip>;
+    cache_hit: z.ZodBoolean;
+    details: z.ZodObject<{
+        meta: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            language: z.ZodOptional<z.ZodString>;
+            targets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                runner: z.ZodString;
+                build_flags: z.ZodOptional<z.ZodString>;
+                test_flags: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            release: z.ZodOptional<z.ZodObject<{
+                npm: z.ZodOptional<z.ZodBoolean>;
+                github: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        output_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Schema for a task that was skipped.
+ * Note: 'skip_reason' is required here, and fields like 'hash' or 'elapsed' are omitted.
+ */
+declare const SkippedTaskSchema: z.ZodObject<{
+    status: z.ZodLiteral<"skipped">;
+    task: z.ZodObject<{
+        task_name: z.ZodString;
+        task_command: z.ZodString;
+        project_name: z.ZodString;
+        project_dir: z.ZodString;
+        full_task_name: z.ZodString;
+        dependencies: z.ZodArray<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+        interactive: z.ZodBoolean;
+        persistent: z.ZodBoolean;
+    }, z.core.$strip>;
+    skip_reason: z.ZodString;
+    details: z.ZodObject<{
+        meta: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            language: z.ZodOptional<z.ZodString>;
+            targets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                runner: z.ZodString;
+                build_flags: z.ZodOptional<z.ZodString>;
+                test_flags: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            release: z.ZodOptional<z.ZodObject<{
+                npm: z.ZodOptional<z.ZodBoolean>;
+                github: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        output_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * The primary schema for a single task result, using a discriminated union
+ * based on the 'status' field to correctly type the required fields.
+ */
+export declare const TaskResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"completed">;
+    hash: z.ZodString;
+    task: z.ZodObject<{
+        task_name: z.ZodString;
+        task_command: z.ZodString;
+        project_name: z.ZodString;
+        project_dir: z.ZodString;
+        full_task_name: z.ZodString;
+        dependencies: z.ZodArray<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+        interactive: z.ZodBoolean;
+        persistent: z.ZodBoolean;
+    }, z.core.$strip>;
+    exit_code: z.ZodNumber;
+    elapsed: z.ZodObject<{
+        secs: z.ZodNumber;
+        nanos: z.ZodNumber;
+    }, z.core.$strip>;
+    cache_hit: z.ZodBoolean;
+    details: z.ZodObject<{
+        meta: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            language: z.ZodOptional<z.ZodString>;
+            targets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                runner: z.ZodString;
+                build_flags: z.ZodOptional<z.ZodString>;
+                test_flags: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            release: z.ZodOptional<z.ZodObject<{
+                npm: z.ZodOptional<z.ZodBoolean>;
+                github: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        output_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"skipped">;
+    task: z.ZodObject<{
+        task_name: z.ZodString;
+        task_command: z.ZodString;
+        project_name: z.ZodString;
+        project_dir: z.ZodString;
+        full_task_name: z.ZodString;
+        dependencies: z.ZodArray<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+        interactive: z.ZodBoolean;
+        persistent: z.ZodBoolean;
+    }, z.core.$strip>;
+    skip_reason: z.ZodString;
+    details: z.ZodObject<{
+        meta: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            language: z.ZodOptional<z.ZodString>;
+            targets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                runner: z.ZodString;
+                build_flags: z.ZodOptional<z.ZodString>;
+                test_flags: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            release: z.ZodOptional<z.ZodObject<{
+                npm: z.ZodOptional<z.ZodBoolean>;
+                github: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        output_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"errored">;
+    task: z.ZodObject<{
+        task_name: z.ZodString;
+        task_command: z.ZodString;
+        project_name: z.ZodString;
+        project_dir: z.ZodString;
+        full_task_name: z.ZodString;
+        dependencies: z.ZodArray<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+        interactive: z.ZodBoolean;
+        persistent: z.ZodBoolean;
+    }, z.core.$strip>;
+    error: z.ZodString;
+    details: z.ZodObject<{
+        meta: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            language: z.ZodOptional<z.ZodString>;
+            targets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                runner: z.ZodString;
+                build_flags: z.ZodOptional<z.ZodString>;
+                test_flags: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            release: z.ZodOptional<z.ZodObject<{
+                npm: z.ZodOptional<z.ZodBoolean>;
+                github: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        output_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "status">;
+/**
+ * The final schema for the root array of task results.
+ */
+export declare const TaskResultArraySchema: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"completed">;
+    hash: z.ZodString;
+    task: z.ZodObject<{
+        task_name: z.ZodString;
+        task_command: z.ZodString;
+        project_name: z.ZodString;
+        project_dir: z.ZodString;
+        full_task_name: z.ZodString;
+        dependencies: z.ZodArray<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+        interactive: z.ZodBoolean;
+        persistent: z.ZodBoolean;
+    }, z.core.$strip>;
+    exit_code: z.ZodNumber;
+    elapsed: z.ZodObject<{
+        secs: z.ZodNumber;
+        nanos: z.ZodNumber;
+    }, z.core.$strip>;
+    cache_hit: z.ZodBoolean;
+    details: z.ZodObject<{
+        meta: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            language: z.ZodOptional<z.ZodString>;
+            targets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                runner: z.ZodString;
+                build_flags: z.ZodOptional<z.ZodString>;
+                test_flags: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            release: z.ZodOptional<z.ZodObject<{
+                npm: z.ZodOptional<z.ZodBoolean>;
+                github: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        output_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"skipped">;
+    task: z.ZodObject<{
+        task_name: z.ZodString;
+        task_command: z.ZodString;
+        project_name: z.ZodString;
+        project_dir: z.ZodString;
+        full_task_name: z.ZodString;
+        dependencies: z.ZodArray<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+        interactive: z.ZodBoolean;
+        persistent: z.ZodBoolean;
+    }, z.core.$strip>;
+    skip_reason: z.ZodString;
+    details: z.ZodObject<{
+        meta: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            language: z.ZodOptional<z.ZodString>;
+            targets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                runner: z.ZodString;
+                build_flags: z.ZodOptional<z.ZodString>;
+                test_flags: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            release: z.ZodOptional<z.ZodObject<{
+                npm: z.ZodOptional<z.ZodBoolean>;
+                github: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        output_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"errored">;
+    task: z.ZodObject<{
+        task_name: z.ZodString;
+        task_command: z.ZodString;
+        project_name: z.ZodString;
+        project_dir: z.ZodString;
+        full_task_name: z.ZodString;
+        dependencies: z.ZodArray<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
+        interactive: z.ZodBoolean;
+        persistent: z.ZodBoolean;
+    }, z.core.$strip>;
+    error: z.ZodString;
+    details: z.ZodObject<{
+        meta: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            language: z.ZodOptional<z.ZodString>;
+            targets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                runner: z.ZodString;
+                build_flags: z.ZodOptional<z.ZodString>;
+                test_flags: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            release: z.ZodOptional<z.ZodObject<{
+                npm: z.ZodOptional<z.ZodBoolean>;
+                github: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        output_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "status">>;
+export type Elapsed = z.infer<typeof ElapsedSchema>;
+export type Meta = z.infer<typeof MetaSchema>;
+export type Task = z.infer<typeof TaskSchema>;
+export type CompletedTaskResult = z.infer<typeof CompletedTaskSchema>;
+export type SkippedTaskResult = z.infer<typeof SkippedTaskSchema>;
+export type TaskResult = z.infer<typeof TaskResultSchema>;
+export type TaskResultArray = z.infer<typeof TaskResultArraySchema>;
+export {};
+//# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;GAEG;AACH,QAAA,MAAM,aAAa;;;iBAWjB,CAAC;AAmBH;;GAEG;AACH,QAAA,MAAM,UAAU;;;;;;;;;;;;iBAcd,CAAC;AAUH;;GAEG;AACH,QAAA,MAAM,UAAU;;;;;;;;;;iBAwBd,CAAC;AAIH;;;GAGG;AACH,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmBvB,CAAC;AASH;;;GAGG;AACH,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOrB,CAAC;AAIH;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAQxB,CAAC;AAEN;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAEkB,CAAC;AAIrD,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAC9C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAC9C,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACtE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAClE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/utils-CSiXyoWV.mjs

@@ -0,0 +1,96 @@
+import { z as e } from "zod";
+const c = e.object({
+  secs: e.number().int().nonnegative().describe("The number of whole seconds elapsed."),
+  nanos: e.number().int().nonnegative().describe("The number of nanoseconds elapsed.")
+}), l = e.object({
+  runner: e.string().describe("The runner to use for the target."),
+  build_flags: e.string().optional().describe("The build flags to use for the target."),
+  test_flags: e.string().optional().describe("The test flags to use for the target.")
+}), d = e.object({
+  npm: e.boolean().optional().describe("Whether to publish to npm."),
+  github: e.boolean().optional().describe("Whether to publish to github.")
+}), u = e.object({
+  type: e.string().optional().describe("The type of project (e.g., library, service, application)."),
+  language: e.string().optional().describe("The primary language of the project."),
+  targets: e.record(e.string(), l).optional().describe("The targets to build."),
+  release: d.optional()
+}), o = e.object({
+  meta: u.optional(),
+  output_files: e.array(e.string()).optional().describe("The output files generated.")
+}), n = e.object({
+  task_name: e.string().describe("The short name of the task (e.g., 'test', 'build')."),
+  task_command: e.string().describe("The command executed for the task."),
+  project_name: e.string().describe("The name of the project."),
+  project_dir: e.string().describe("The absolute directory path of the project."),
+  full_task_name: e.string().describe("The fully qualified task name (e.g., 'omni_utils#test')."),
+  dependencies: e.array(e.string()).describe("A list of dependent task names."),
+  enabled: e.boolean().or(e.string()).optional().describe(
+    "Whether the task is enabled by configuration. Either a boolean or a tera template string that evaluates to a boolean."
+  ),
+  interactive: e.boolean().describe("Whether the task is interactive."),
+  persistent: e.boolean().describe("Whether the task is persistent.")
+}), h = e.object({
+  status: e.literal("completed"),
+  hash: e.string().describe(
+    "The task's content hash (Base64 encoded string). Used for caching."
+  ),
+  task: n,
+  exit_code: e.number().int().describe(
+    "The exit code of the executed command (typically 0 for success)."
+  ),
+  elapsed: c.describe("The duration the task took to execute."),
+  cache_hit: e.boolean().describe("Indicates if the result was pulled from cache."),
+  details: o
+}), p = e.object({
+  status: e.literal("errored"),
+  task: n,
+  error: e.string().describe("The error message."),
+  details: o
+}), b = e.object({
+  status: e.literal("skipped"),
+  task: n,
+  skip_reason: e.string().describe("The reason the task was skipped (e.g., 'disabled')."),
+  details: o
+}), m = e.discriminatedUnion("status", [
+  h,
+  b,
+  p
+]).describe(
+  "Schema for a single task execution result (completed or skipped)."
+), f = e.array(m).describe("An array of task execution results.");
+function k(a) {
+  const s = {
+    test: {
+      rust: [],
+      typescript: []
+    },
+    build: {
+      rust: [],
+      typescript: []
+    },
+    publish: {
+      npm: [],
+      rust_github: []
+    }
+  };
+  for (const t of a) {
+    if (t.status === "skipped")
+      continue;
+    const r = t.task;
+    r.task_name === "test" && (t.details.meta?.language === "rust" && s.test.rust.push(i(t)), t.details.meta?.language === "typescript" && s.test.typescript.push(i(t))), r.task_name === "build" && (t.details.meta?.language === "rust" && s.build.rust.push(i(t)), t.details.meta?.language === "typescript" && s.build.typescript.push(i(t))), r.task_name === "publish" && t.details.meta?.release?.npm && s.publish.npm.push(i(t)), t.details.meta?.release?.github && t.details.meta?.language === "rust" && s.publish.rust_github.push(i(t));
+  }
+  return s;
+}
+function i(a) {
+  return {
+    task_name: a.task.task_name,
+    project_name: a.task.project_name,
+    output_files: a.details.output_files ?? [],
+    meta: a.details.meta ?? {}
+  };
+}
+export {
+  f as T,
+  m as a,
+  k as c
+};

package/dist/utils-DeP5M93O.js

@@ -0,0 +1 @@
+"use strict";const e=require("zod"),l=e.z.object({secs:e.z.number().int().nonnegative().describe("The number of whole seconds elapsed."),nanos:e.z.number().int().nonnegative().describe("The number of nanoseconds elapsed.")}),d=e.z.object({runner:e.z.string().describe("The runner to use for the target."),build_flags:e.z.string().optional().describe("The build flags to use for the target."),test_flags:e.z.string().optional().describe("The test flags to use for the target.")}),u=e.z.object({npm:e.z.boolean().optional().describe("Whether to publish to npm."),github:e.z.boolean().optional().describe("Whether to publish to github.")}),h=e.z.object({type:e.z.string().optional().describe("The type of project (e.g., library, service, application)."),language:e.z.string().optional().describe("The primary language of the project."),targets:e.z.record(e.z.string(),d).optional().describe("The targets to build."),release:u.optional()}),o=e.z.object({meta:h.optional(),output_files:e.z.array(e.z.string()).optional().describe("The output files generated.")}),n=e.z.object({task_name:e.z.string().describe("The short name of the task (e.g., 'test', 'build')."),task_command:e.z.string().describe("The command executed for the task."),project_name:e.z.string().describe("The name of the project."),project_dir:e.z.string().describe("The absolute directory path of the project."),full_task_name:e.z.string().describe("The fully qualified task name (e.g., 'omni_utils#test')."),dependencies:e.z.array(e.z.string()).describe("A list of dependent task names."),enabled:e.z.boolean().or(e.z.string()).optional().describe("Whether the task is enabled by configuration. Either a boolean or a tera template string that evaluates to a boolean."),interactive:e.z.boolean().describe("Whether the task is interactive."),persistent:e.z.boolean().describe("Whether the task is persistent.")}),p=e.z.object({status:e.z.literal("completed"),hash:e.z.string().describe("The task's content hash (Base64 encoded string). Used for caching."),task:n,exit_code:e.z.number().int().describe("The exit code of the executed command (typically 0 for success)."),elapsed:l.describe("The duration the task took to execute."),cache_hit:e.z.boolean().describe("Indicates if the result was pulled from cache."),details:o}),b=e.z.object({status:e.z.literal("errored"),task:n,error:e.z.string().describe("The error message."),details:o}),m=e.z.object({status:e.z.literal("skipped"),task:n,skip_reason:e.z.string().describe("The reason the task was skipped (e.g., 'disabled')."),details:o}),c=e.z.discriminatedUnion("status",[p,m,b]).describe("Schema for a single task execution result (completed or skipped)."),g=e.z.array(c).describe("An array of task execution results.");function f(a){const s={test:{rust:[],typescript:[]},build:{rust:[],typescript:[]},publish:{npm:[],rust_github:[]}};for(const t of a){if(t.status==="skipped")continue;const r=t.task;r.task_name==="test"&&(t.details.meta?.language==="rust"&&s.test.rust.push(i(t)),t.details.meta?.language==="typescript"&&s.test.typescript.push(i(t))),r.task_name==="build"&&(t.details.meta?.language==="rust"&&s.build.rust.push(i(t)),t.details.meta?.language==="typescript"&&s.build.typescript.push(i(t))),r.task_name==="publish"&&t.details.meta?.release?.npm&&s.publish.npm.push(i(t)),t.details.meta?.release?.github&&t.details.meta?.language==="rust"&&s.publish.rust_github.push(i(t))}return s}function i(a){return{task_name:a.task.task_name,project_name:a.task.project_name,output_files:a.details.output_files??[],meta:a.details.meta??{}}}exports.TaskResultArraySchema=g;exports.TaskResultSchema=c;exports.createJobs=f;

package/dist/utils.d.ts

@@ -0,0 +1,26 @@
+import { Meta, TaskResultArray } from './schemas';
+export type Job = {
+    task_name: string;
+    project_name: string;
+    output_files: string[];
+    meta: Meta;
+};
+export type Jobs = {
+    test: TestJobs;
+    build: BuildJobs;
+    publish: PublishJobs;
+};
+export type TestJobs = {
+    rust: Job[];
+    typescript: Job[];
+};
+export type BuildJobs = {
+    rust: Job[];
+    typescript: Job[];
+};
+export type PublishJobs = {
+    npm: Job[];
+    rust_github: Job[];
+};
+export declare function createJobs(results: TaskResultArray): Jobs;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAc,eAAe,EAAE,MAAM,WAAW,CAAC;AAEnE,MAAM,MAAM,GAAG,GAAG;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,IAAI,EAAE,IAAI,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG;IACf,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,SAAS,CAAC;IACjB,OAAO,EAAE,WAAW,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACnB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,UAAU,EAAE,GAAG,EAAE,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACpB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,UAAU,EAAE,GAAG,EAAE,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACtB,GAAG,EAAE,GAAG,EAAE,CAAC;IACX,WAAW,EAAE,GAAG,EAAE,CAAC;CACtB,CAAC;AAEF,wBAAgB,UAAU,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI,CAuDzD"}

package/package.json

@@ -0,0 +1,34 @@
+{
+    "name": "@omni-oss/create-jobs",
+    "version": "0.0.1",
+    "bin": "./dist/create-jobs.mjs",
+    "publishConfig": {
+        "access": "public"
+    },
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": {
+                "development": "./src/index.ts",
+                "default": "./dist/index.mjs"
+            },
+            "require": {
+                "development": "./src/index.ts",
+                "default": "./dist/index.cjs"
+            }
+        }
+    },
+    "dependencies": {
+        "zod": "^4.3.6",
+        "commander": "^14.0.3",
+        "@commander-js/extra-typings": "14.0.0"
+    },
+    "devDependencies": {
+        "@omni-oss/tsconfig": "^0.1.0",
+        "@omni-oss/vite-config": "^0.1.0",
+        "@omni-oss/vitest-config": "^0.0.0",
+        "typescript": "^5.9.3",
+        "@types/node": "25.2.0",
+        "@types/bun": "^1.3.8"
+    }
+}

package/project.omni.yaml

@@ -0,0 +1,29 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/omni-oss/omni/refs/heads/json-schemas/project-latest.json
+name: "@omni-oss/create-jobs"
+
+extends:
+  - "@workspace/omni/presets/ts-vite-script.omni.yaml"
+
+tasks:
+  test:unit:
+    enabled: true
+
+  test:integration:
+    enabled: true
+
+  test:
+    enabled: true
+
+  build:
+    enabled: true
+
+  publish:
+    enabled: true
+
+meta:
+  publish: true
+
+dependencies:
+  - "@omni-oss/tsconfig"
+  - "@omni-oss/vite-config"
+  - "@omni-oss/vitest-config"

package/src/cli/index.ts

@@ -0,0 +1,31 @@
+import fsAsync from "node:fs/promises";
+import { Command } from "@commander-js/extra-typings";
+import { createJobs, TaskResultArraySchema } from "..";
+
+const command = new Command();
+
+command
+    .argument("<input>", "The input file to read from.")
+    .option("-o, --output <output>", "The output file to write to.")
+    .action(async (input, options) => {
+        const inputFile = await fsAsync.readFile(input, "utf-8");
+        const results = JSON.parse(inputFile);
+        const result = TaskResultArraySchema.safeParse(results);
+
+        if (result.success) {
+            const data = result.data;
+            const processed = createJobs(data);
+            if (options.output) {
+                await fsAsync.writeFile(
+                    options.output,
+                    JSON.stringify(processed, null, 2),
+                );
+            } else {
+                console.log(processed);
+            }
+        } else {
+            console.error(result.error);
+            process.exit(1);
+        }
+    })
+    .parseAsync();

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./schemas";
+export * from "./utils";

package/src/schemas.ts

@@ -0,0 +1,172 @@
+import { z } from "zod";
+
+// --- Nested Schemas ---
+
+/**
+ * Defines the structure for the duration object.
+ */
+const ElapsedSchema = z.object({
+    secs: z
+        .number()
+        .int()
+        .nonnegative()
+        .describe("The number of whole seconds elapsed."),
+    nanos: z
+        .number()
+        .int()
+        .nonnegative()
+        .describe("The number of nanoseconds elapsed."),
+});
+
+const TargetSchema = z.object({
+    runner: z.string().describe("The runner to use for the target."),
+    build_flags: z
+        .string()
+        .optional()
+        .describe("The build flags to use for the target."),
+    test_flags: z
+        .string()
+        .optional()
+        .describe("The test flags to use for the target."),
+});
+
+const ReleaseSchema = z.object({
+    npm: z.boolean().optional().describe("Whether to publish to npm."),
+    github: z.boolean().optional().describe("Whether to publish to github."),
+});
+
+/**
+ * Defines the metadata for the project/task details.
+ */
+const MetaSchema = z.object({
+    type: z
+        .string()
+        .optional()
+        .describe("The type of project (e.g., library, service, application)."),
+    language: z
+        .string()
+        .optional()
+        .describe("The primary language of the project."),
+    targets: z
+        .record(z.string(), TargetSchema)
+        .optional()
+        .describe("The targets to build."),
+    release: ReleaseSchema.optional(),
+});
+
+const DetailsSchema = z.object({
+    meta: MetaSchema.optional(),
+    output_files: z
+        .array(z.string())
+        .optional()
+        .describe("The output files generated."),
+});
+
+/**
+ * Defines the details of the task that was run or skipped.
+ */
+const TaskSchema = z.object({
+    task_name: z
+        .string()
+        .describe("The short name of the task (e.g., 'test', 'build')."),
+    task_command: z.string().describe("The command executed for the task."),
+    project_name: z.string().describe("The name of the project."),
+    project_dir: z
+        .string()
+        .describe("The absolute directory path of the project."),
+    full_task_name: z
+        .string()
+        .describe("The fully qualified task name (e.g., 'omni_utils#test')."),
+    dependencies: z
+        .array(z.string())
+        .describe("A list of dependent task names."),
+    enabled: z
+        .boolean()
+        .or(z.string())
+        .optional()
+        .describe(
+            "Whether the task is enabled by configuration. Either a boolean or a tera template string that evaluates to a boolean.",
+        ),
+    interactive: z.boolean().describe("Whether the task is interactive."),
+    persistent: z.boolean().describe("Whether the task is persistent."),
+});
+
+// --- Discriminant Schemas (Union Members) ---
+
+/**
+ * Schema for a task that successfully completed.
+ * Note: 'elapsed', 'exit_code', 'hash', and 'cache_hit' are required here.
+ */
+const CompletedTaskSchema = z.object({
+    status: z.literal("completed"),
+    hash: z
+        .string()
+        .describe(
+            "The task's content hash (Base64 encoded string). Used for caching.",
+        ),
+    task: TaskSchema,
+    exit_code: z
+        .number()
+        .int()
+        .describe(
+            "The exit code of the executed command (typically 0 for success).",
+        ),
+    elapsed: ElapsedSchema.describe("The duration the task took to execute."),
+    cache_hit: z
+        .boolean()
+        .describe("Indicates if the result was pulled from cache."),
+    details: DetailsSchema,
+});
+
+const ErroredTaskSchema = z.object({
+    status: z.literal("errored"),
+    task: TaskSchema,
+    error: z.string().describe("The error message."),
+    details: DetailsSchema,
+});
+
+/**
+ * Schema for a task that was skipped.
+ * Note: 'skip_reason' is required here, and fields like 'hash' or 'elapsed' are omitted.
+ */
+const SkippedTaskSchema = z.object({
+    status: z.literal("skipped"),
+    task: TaskSchema,
+    skip_reason: z
+        .string()
+        .describe("The reason the task was skipped (e.g., 'disabled')."),
+    details: DetailsSchema,
+});
+
+// --- Root Schema ---
+
+/**
+ * The primary schema for a single task result, using a discriminated union
+ * based on the 'status' field to correctly type the required fields.
+ */
+export const TaskResultSchema = z
+    .discriminatedUnion("status", [
+        CompletedTaskSchema,
+        SkippedTaskSchema,
+        ErroredTaskSchema,
+    ])
+    .describe(
+        "Schema for a single task execution result (completed or skipped).",
+    );
+
+/**
+ * The final schema for the root array of task results.
+ */
+export const TaskResultArraySchema = z
+    .array(TaskResultSchema)
+    .describe("An array of task execution results.");
+
+// --- TypeScript Types (Inferred) ---
+
+export type Elapsed = z.infer<typeof ElapsedSchema>;
+export type Meta = z.infer<typeof MetaSchema>;
+export type Task = z.infer<typeof TaskSchema>;
+export type CompletedTaskResult = z.infer<typeof CompletedTaskSchema>;
+export type SkippedTaskResult = z.infer<typeof SkippedTaskSchema>;
+export type TaskResult = z.infer<typeof TaskResultSchema>;
+export type TaskResultArray = z.infer<typeof TaskResultArraySchema>;

package/src/utils.ts

@@ -0,0 +1,95 @@
+import type { Meta, TaskResult, TaskResultArray } from "./schemas";
+
+export type Job = {
+    task_name: string;
+    project_name: string;
+    output_files: string[];
+    meta: Meta;
+};
+
+export type Jobs = {
+    test: TestJobs;
+    build: BuildJobs;
+    publish: PublishJobs;
+};
+
+export type TestJobs = {
+    rust: Job[];
+    typescript: Job[];
+};
+
+export type BuildJobs = {
+    rust: Job[];
+    typescript: Job[];
+};
+
+export type PublishJobs = {
+    npm: Job[];
+    rust_github: Job[];
+};
+
+export function createJobs(results: TaskResultArray): Jobs {
+    const jobs: Jobs = {
+        test: {
+            rust: [],
+            typescript: [],
+        },
+        build: {
+            rust: [],
+            typescript: [],
+        },
+        publish: {
+            npm: [],
+            rust_github: [],
+        },
+    };
+
+    for (const result of results) {
+        if (result.status === "skipped") {
+            continue;
+        }
+
+        const task = result.task;
+        if (task.task_name === "test") {
+            if (result.details.meta?.language === "rust") {
+                jobs.test.rust.push(jobFromResult(result));
+            }
+
+            if (result.details.meta?.language === "typescript") {
+                jobs.test.typescript.push(jobFromResult(result));
+            }
+        }
+
+        if (task.task_name === "build") {
+            if (result.details.meta?.language === "rust") {
+                jobs.build.rust.push(jobFromResult(result));
+            }
+
+            if (result.details.meta?.language === "typescript") {
+                jobs.build.typescript.push(jobFromResult(result));
+            }
+        }
+
+        if (task.task_name === "publish" && result.details.meta?.release?.npm) {
+            jobs.publish.npm.push(jobFromResult(result));
+        }
+
+        if (
+            result.details.meta?.release?.github &&
+            result.details.meta?.language === "rust"
+        ) {
+            jobs.publish.rust_github.push(jobFromResult(result));
+        }
+    }
+
+    return jobs;
+}
+
+function jobFromResult(result: TaskResult): Job {
+    return {
+        task_name: result.task.task_name,
+        project_name: result.task.project_name,
+        output_files: result.details.output_files ?? [],
+        meta: result.details.meta ?? {},
+    };
+}

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+	"extends": ["@omni-oss/tsconfig/with-paths.json", "./tsconfig.project.json"],
+}

package/tsconfig.project.json

@@ -0,0 +1,5 @@
+{
+    "compilerOptions": {
+        "outDir": "./dist"
+    }
+}

package/tsconfig.types.json

@@ -0,0 +1,3 @@
+{
+    "extends": ["@omni-oss/tsconfig/types.json", "./tsconfig.project.json"]
+}

package/vite.config.ts

@@ -0,0 +1,30 @@
+import createBaseConfig from "@omni-oss/vite-config/script";
+import { mergeConfig, type UserConfig } from "vite";
+import { dependencies } from "./package.json";
+
+const baseConfig = createBaseConfig({
+    generateTypes: true,
+});
+
+const externalNodeDeps = ["node:path", "node:fs", "node:fs/promises"];
+
+export default mergeConfig(baseConfig, {
+    build: {
+        minify: "esbuild",
+        lib: {
+            entry: {
+                "create-jobs": "src/cli/index.ts",
+                index: "src/index.ts",
+            },
+
+            formats: ["es", "cjs"],
+            fileName: (format, entryName) =>
+                `${entryName || "create-jobs"}.${format === "cjs" ? "cjs" : "mjs"}`,
+            name: "CreateJobs",
+        },
+
+        rollupOptions: {
+            external: [...Object.keys(dependencies), ...externalNodeDeps],
+        },
+    },
+} satisfies UserConfig);

package/vitest.config.integration.ts

@@ -0,0 +1,12 @@
+import { mergeConfig, type UserWorkspaceConfig } from "vitest/config";
+import baseConfig from "./vite.config";
+import integrationTestConfig from "@omni-oss/vitest-config/integration";
+
+export default mergeConfig(mergeConfig(baseConfig, integrationTestConfig), {
+    test: {
+        testTimeout: 1000,
+        include: [
+            "./src/**/__tests__/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}",
+        ],
+    },
+} satisfies UserWorkspaceConfig);

package/vitest.config.unit.ts

@@ -0,0 +1,13 @@
+import { mergeConfig, type UserWorkspaceConfig } from "vitest/config";
+import baseConfig from "./vite.config";
+import unitTestConfig from "@omni-oss/vitest-config/unit";
+
+export default mergeConfig(mergeConfig(baseConfig, unitTestConfig), {
+    test: {
+        testTimeout: 1000,
+        include: ["./src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"],
+        exclude: [
+            "./src/**/__tests__/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}",
+        ],
+    },
+} satisfies UserWorkspaceConfig);