@justram/pie 0.2.1 → 0.2.3

package/CHANGELOG.md

@@ -12,6 +12,34 @@
 
 ### Removed
 
+## 0.2.3
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- Renamed the publish script to avoid recursive `npm publish` runs.
+
+### Removed
+
+## 0.2.2
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- Added release automation scripts and documented the release flow.
+
+### Removed
+
 ## 0.2.1
 
 ### Breaking Changes

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@justram/pie",
-	"version": "0.2.1",
+	"version": "0.2.3",
 	"description": "Structured extraction library and CLI built on @mariozechner/pi-ai.",
 	"license": "MIT",
 	"keywords": [
@@ -49,6 +49,17 @@
 		"test": "vitest run",
 		"test:watch": "vitest",
 		"test:e2e": "vitest run --config vitest.config.e2e.ts",
+		"clean": "rm -rf dist",
+		"version:patch": "npm version patch --no-git-tag-version && node scripts/sync-versions.js",
+		"version:minor": "npm version minor --no-git-tag-version && node scripts/sync-versions.js",
+		"version:major": "npm version major --no-git-tag-version && node scripts/sync-versions.js",
+		"version:set": "npm version --no-git-tag-version",
+		"prepublishOnly": "npm run clean && npm run build && npm run check",
+		"publish:public": "npm run prepublishOnly && npm publish --access public",
+		"publish:dry": "npm run prepublishOnly && npm publish --access public --dry-run",
+		"release:patch": "node scripts/release.mjs patch",
+		"release:minor": "node scripts/release.mjs minor",
+		"release:major": "node scripts/release.mjs major",
 		"prepare": "husky"
 	},
 	"dependencies": {

package/dist/core/helpers.d.ts

@@ -1,5 +0,0 @@
-import type { AssistantMessage, ImageContent, Message, ToolCall } from "@mariozechner/pi-ai";
-export declare function buildMessages(input: string | Message[], attachments?: ImageContent[]): Message[];
-export declare function findToolCall(message: AssistantMessage, toolName: string): ToolCall | undefined;
-export declare function getTextContent(message: AssistantMessage): string;
-export declare function parseJsonFromText(message: AssistantMessage): unknown | null;

package/dist/core/helpers.js

@@ -1,80 +0,0 @@
-export function buildMessages(input, attachments) {
-    if (typeof input !== "string") {
-        return input;
-    }
-    const content = attachments?.length
-        ? [{ type: "text", text: input }, ...attachments]
-        : input;
-    const message = {
-        role: "user",
-        content,
-        timestamp: Date.now(),
-    };
-    return [message];
-}
-export function findToolCall(message, toolName) {
-    for (const content of message.content) {
-        if (content.type === "toolCall" && content.name === toolName) {
-            return content;
-        }
-    }
-    return undefined;
-}
-export function getTextContent(message) {
-    return message.content
-        .filter((content) => content.type === "text")
-        .map((content) => content.text)
-        .join("\n")
-        .trim();
-}
-export function parseJsonFromText(message) {
-    const text = getTextContent(message);
-    if (!text) {
-        return null;
-    }
-    const candidates = collectJsonCandidates(text);
-    for (const candidate of candidates) {
-        const parsed = tryParseJson(candidate);
-        if (parsed !== null) {
-            return parsed;
-        }
-    }
-    return null;
-}
-function collectJsonCandidates(text) {
-    const candidates = [];
-    const fenced = extractFencedJson(text);
-    if (fenced) {
-        candidates.push(fenced);
-    }
-    candidates.push(text);
-    const objectCandidate = sliceBetween(text, "{", "}");
-    if (objectCandidate) {
-        candidates.push(objectCandidate);
-    }
-    const arrayCandidate = sliceBetween(text, "[", "]");
-    if (arrayCandidate) {
-        candidates.push(arrayCandidate);
-    }
-    return candidates;
-}
-function extractFencedJson(text) {
-    const match = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
-    return match ? match[1].trim() : null;
-}
-function sliceBetween(text, open, close) {
-    const start = text.indexOf(open);
-    const end = text.lastIndexOf(close);
-    if (start === -1 || end === -1 || end <= start) {
-        return null;
-    }
-    return text.slice(start, end + 1).trim();
-}
-function tryParseJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return null;
-    }
-}

package/dist/core/validators/assert.d.ts

@@ -1 +0,0 @@
-export declare function runAsserts(data: unknown, asserts: string[], signal?: AbortSignal): Promise<void>;

package/dist/core/validators/assert.js

@@ -1,18 +0,0 @@
-import { AssertionError } from "../errors.js";
-import { runShell } from "./shell.js";
-function shSingleQuote(text) {
-    // Wrap in single quotes, escaping any embedded single quotes:
-    // abc'def -> 'abc'\''def'
-    return `'${text.replaceAll("'", "'\\''")}'`;
-}
-export async function runAsserts(data, asserts, signal) {
-    const json = JSON.stringify(data);
-    for (const expr of asserts) {
-        const result = await runShell(`jq -e ${shSingleQuote(expr)}`, { stdin: json, signal });
-        if (result.code === 0) {
-            continue;
-        }
-        const message = result.stderr.trim() || `Assertion failed: ${expr}`;
-        throw new AssertionError(message, expr);
-    }
-}

package/dist/runtime/node.d.ts

@@ -1,2 +0,0 @@
-import type { Runtime } from "./types.js";
-export declare function createNodeRuntime(): Runtime;

package/dist/runtime/node.js

@@ -1,71 +0,0 @@
-import { createHash } from "node:crypto";
-import { readFile, rm, stat, writeFile, mkdir } from "node:fs/promises";
-import { spawn } from "node:child_process";
-export function createNodeRuntime() {
-    return {
-        now: () => Date.now(),
-        env: {
-            get: (name) => process.env[name],
-        },
-        fs: {
-            exists: async (path) => {
-                try {
-                    await stat(path);
-                    return true;
-                }
-                catch {
-                    return false;
-                }
-            },
-            readFile: async (path) => {
-                const buf = await readFile(path);
-                return new Uint8Array(buf);
-            },
-            readTextFile: async (path) => {
-                return await readFile(path, { encoding: "utf8" });
-            },
-            writeFile: async (path, data) => {
-                await writeFile(path, data);
-            },
-            writeTextFile: async (path, text) => {
-                await writeFile(path, text, { encoding: "utf8" });
-            },
-            mkdir: async (path, options) => {
-                await mkdir(path, { recursive: options?.recursive ?? false });
-            },
-            remove: async (path, options) => {
-                await rm(path, { recursive: options?.recursive ?? false, force: true });
-            },
-        },
-        crypto: {
-            sha256Hex: async (text) => {
-                return createHash("sha256").update(text).digest("hex");
-            },
-        },
-        process: {
-            runShell: async (command, options) => {
-                const child = spawn("sh", ["-c", command], {
-                    stdio: ["pipe", "pipe", "pipe"],
-                    signal: options?.signal,
-                });
-                const stdoutChunks = [];
-                const stderrChunks = [];
-                child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
-                child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
-                if (options?.stdin !== undefined) {
-                    child.stdin.write(options.stdin);
-                }
-                child.stdin.end();
-                const code = await new Promise((resolve, reject) => {
-                    child.on("error", reject);
-                    child.on("close", (c) => resolve(c ?? 0));
-                });
-                return {
-                    code,
-                    stdout: Buffer.concat(stdoutChunks).toString("utf8"),
-                    stderr: Buffer.concat(stderrChunks).toString("utf8"),
-                };
-            },
-        },
-    };
-}

package/dist/runtime/types.d.ts

@@ -1,32 +0,0 @@
-export interface Runtime {
-    now(): number;
-    env: {
-        get(name: string): string | undefined;
-    };
-    fs: {
-        exists(path: string): Promise<boolean>;
-        readFile(path: string): Promise<Uint8Array>;
-        readTextFile(path: string): Promise<string>;
-        writeFile(path: string, data: Uint8Array): Promise<void>;
-        writeTextFile(path: string, text: string): Promise<void>;
-        mkdir(path: string, options?: {
-            recursive?: boolean;
-        }): Promise<void>;
-        remove(path: string, options?: {
-            recursive?: boolean;
-        }): Promise<void>;
-    };
-    crypto: {
-        sha256Hex(text: string): Promise<string>;
-    };
-    process: {
-        runShell(command: string, options?: {
-            stdin?: string;
-            signal?: AbortSignal;
-        }): Promise<{
-            code: number;
-            stdout: string;
-            stderr: string;
-        }>;
-    };
-}

package/dist/runtime/types.js

@@ -1 +0,0 @@
-export {};