orizu 0.3.7 → 0.4.1

package/dist/setup-prompt.js

@@ -0,0 +1,22 @@
+export function renderAgentSetupPrompt(options) {
+    const workspaceLine = options?.workspacePath
+        ? `- Local Orizu artifacts belong under ${options.workspacePath} (gitignored). Keep secrets out of the repo; credentials live in ~/.config/orizu.`
+        : '- If local Orizu artifacts are needed, suggest creating a gitignored .orizu/ workspace (orizu setup can do this).';
+    return `Help me embed Orizu (eval-first LLM optimization) into this repository's workflow.
+
+Start by learning the Orizu workflow:
+1. Run \`orizu skills path --json\` and read the SKILL.md it points to, plus the references it links.
+2. Run \`orizu --version\` and \`orizu whoami\` to confirm the CLI is installed and authenticated. If either fails, pause and tell me how to fix it (npm i -g orizu, orizu login) before continuing.
+
+Then inspect this repository and propose how Orizu should fit it:
+- Identify the LLM application surfaces worth evaluating (prompts, agents, pipelines) and where their inputs/outputs live.
+- Propose Orizu team(s) and project(s) that match how this repo is organized.
+- Propose datasets: existing data that can be uploaded now, or a concrete plan to collect examples if none exists.
+- Propose which prompts to version in Orizu, and which scorers or LLM judges would capture quality for them.
+- Propose runner artifacts where local execution is needed.
+${workspaceLine}
+
+Important boundaries:
+- Present your plan and get my approval before creating anything on the Orizu server or changing repo files.
+- Never duplicate Orizu runtime behavior (scoring, optimization, auth) in repo code; always go through the orizu CLI.`;
+}

package/dist/skill-installer.js

@@ -1,17 +1,26 @@
-import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from 'fs';
-import { dirname, isAbsolute, relative, resolve } from 'path';
+import { cpSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, realpathSync, rmSync, symlinkSync, writeFileSync, } from 'fs';
+import { dirname, isAbsolute, join, relative, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { homedir } from 'os';
+import { createHash } from 'crypto';
 export const SKILL_NAME = 'orizu-cli';
 export const AGENTS_START_MARKER = '<!-- orizu-cli:start -->';
 export const AGENTS_END_MARKER = '<!-- orizu-cli:end -->';
 export const SKILL_INSTALL_TARGETS = [
     'agent-user',
+    'agents-project',
     'codex-project',
     'claude-user',
     'claude-project',
     'agents-md',
 ];
+export const SKILL_META_FILENAME = '.orizu-skill-meta.json';
+export const SKILL_INSTALL_AGENTS = ['claude', 'codex'];
+const PROJECT_LEVEL_TARGETS = [
+    'agents-project',
+    'codex-project',
+    'claude-project',
+];
 function getCliRoot() {
     return resolve(dirname(fileURLToPath(import.meta.url)), '..');
 }
@@ -25,23 +34,38 @@ export function formatMissingSkillSourceError(paths) {
     return `Unable to find bundled ${SKILL_NAME} skill. Reinstall the orizu CLI or run from the Orizu repository.\n`
         + `Searched:\n- ${paths.join('\n- ')}`;
 }
-export function resolveSkillSourceDir() {
+export function resolveSkillSource() {
     const override = process.env.ORIZU_SKILL_SOURCE_DIR;
     if (override) {
         const resolvedOverride = resolve(override);
         if (!isSkillDir(resolvedOverride)) {
             throw new Error(`ORIZU_SKILL_SOURCE_DIR is not an Orizu skill directory: ${resolvedOverride}`);
         }
-        return resolvedOverride;
+        return {
+            name: SKILL_NAME,
+            root: resolvedOverride,
+            skillMd: resolve(resolvedOverride, 'SKILL.md'),
+            source: 'override',
+        };
     }
     const cliRoot = getCliRoot();
     const packagedSkill = resolve(cliRoot, 'vendor', 'skills', SKILL_NAME);
     if (isSkillDir(packagedSkill)) {
-        return packagedSkill;
+        return {
+            name: SKILL_NAME,
+            root: packagedSkill,
+            skillMd: resolve(packagedSkill, 'SKILL.md'),
+            source: 'packaged',
+        };
     }
     const repoSkill = resolve(cliRoot, '..', '..', 'skills', SKILL_NAME);
     if (isSkillDir(repoSkill)) {
-        return repoSkill;
+        return {
+            name: SKILL_NAME,
+            root: repoSkill,
+            skillMd: resolve(repoSkill, 'SKILL.md'),
+            source: 'repo-fallback',
+        };
     }
     const searchedPaths = [
         `packaged skill: ${packagedSkill}`,
@@ -49,6 +73,38 @@ export function resolveSkillSourceDir() {
     ];
     throw new Error(formatMissingSkillSourceError(searchedPaths));
 }
+export function resolveSkillSourceDir() {
+    return resolveSkillSource().root;
+}
+function listSkillFiles(root, dir, files) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const entryPath = join(dir, entry.name);
+        if (!shouldCopySkillPath(root, entryPath)) {
+            continue;
+        }
+        if (entry.isDirectory()) {
+            listSkillFiles(root, entryPath, files);
+        }
+        else if (entry.isFile()) {
+            files.push(entryPath);
+        }
+    }
+}
+export function computeSkillContentHash(root) {
+    const files = [];
+    listSkillFiles(root, root, files);
+    const hash = createHash('sha256');
+    const sorted = files
+        .map(file => relative(root, file).replace(/\\/g, '/'))
+        .sort();
+    for (const rel of sorted) {
+        hash.update(rel);
+        hash.update('\0');
+        hash.update(readFileSync(join(root, rel)));
+        hash.update('\0');
+    }
+    return `sha256:${hash.digest('hex')}`;
+}
 function resolveHome(options) {
     return resolve(options?.homeDir || process.env.HOME || homedir());
 }
@@ -61,6 +117,9 @@ export function getSkillInstallPath(target, options) {
     if (target === 'agent-user') {
         return resolve(home, '.agents', 'skills', SKILL_NAME);
     }
+    if (target === 'agents-project') {
+        return resolve(cwd, '.agents', 'skills', SKILL_NAME);
+    }
     if (target === 'codex-project') {
         return resolve(cwd, '.codex', 'skills', SKILL_NAME);
     }
@@ -72,6 +131,52 @@ export function getSkillInstallPath(target, options) {
     }
     return resolve(cwd, 'AGENTS.md');
 }
+export function getTargetForAgent(agent, scope) {
+    if (agent === 'claude') {
+        return scope === 'global' ? 'claude-user' : 'claude-project';
+    }
+    return scope === 'global' ? 'agent-user' : 'agents-project';
+}
+export function isSkillInstallAgent(value) {
+    return SKILL_INSTALL_AGENTS.includes(value);
+}
+export function isProjectLevelTarget(target) {
+    return PROJECT_LEVEL_TARGETS.includes(target);
+}
+const UNSTABLE_SOURCE_PATTERNS = [
+    /\/_npx\//,
+    /\/\.npm\//,
+    /\/npm-cache\//,
+    /\/\.bun\/install\/cache\//,
+    /\/bunx-/,
+    /\/dlx-/,
+    /\/\.pnpm-store\//,
+    /^\/tmp\//,
+    /^\/(private\/)?var\/folders\//,
+    /\/Temp\//,
+];
+export function isStableSkillSourcePath(root) {
+    const normalized = root.replace(/\\/g, '/');
+    return !UNSTABLE_SOURCE_PATTERNS.some(pattern => pattern.test(normalized));
+}
+export function resolveEffectiveInstallMode(target, sourceRoot, mode = 'auto') {
+    if (target === 'agents-md') {
+        return 'section';
+    }
+    if (isProjectLevelTarget(target)) {
+        if (mode === 'link') {
+            throw new Error(`--mode link is not supported for project-level target '${target}': committed project files must not symlink to user-local package paths. Use --mode copy.`);
+        }
+        return 'copy';
+    }
+    if (mode === 'link') {
+        return 'link';
+    }
+    if (mode === 'copy') {
+        return 'copy';
+    }
+    return isStableSkillSourcePath(sourceRoot) ? 'link' : 'copy';
+}
 function shouldCopySkillPath(sourceRoot, sourcePath) {
     const rel = relative(sourceRoot, sourcePath).replace(/\\/g, '/');
     if (!rel) {
@@ -83,7 +188,8 @@ function shouldCopySkillPath(sourceRoot, sourcePath) {
     const parts = rel.split('/');
     return !parts.some(part => part === '.DS_Store' ||
         part === '__pycache__' ||
-        part === '.pytest_cache') && !rel.endsWith('.pyc') && !rel.endsWith('.pyo');
+        part === '.pytest_cache' ||
+        part === SKILL_META_FILENAME) && !rel.endsWith('.pyc') && !rel.endsWith('.pyo');
 }
 function copySkillTree(sourceDir, targetDir) {
     rmSync(targetDir, { recursive: true, force: true });
@@ -117,6 +223,7 @@ function installAgentsMd(sourceDir, targetPath, options) {
             target: 'agents-md',
             path: targetPath,
             action: action === 'updated' ? 'would-update' : 'would-create',
+            mode: 'section',
         };
     }
     if (hasManagedSection && !options?.overwrite) {
@@ -125,54 +232,173 @@ function installAgentsMd(sourceDir, targetPath, options) {
     mkdirSync(dirname(targetPath), { recursive: true });
     if (!exists) {
         writeFileSync(targetPath, section, 'utf8');
-        return { target: 'agents-md', path: targetPath, action: 'created' };
+        return { target: 'agents-md', path: targetPath, action: 'created', mode: 'section' };
     }
     if (hasManagedSection) {
         const pattern = new RegExp(`${escapeRegExp(AGENTS_START_MARKER)}[\\s\\S]*?${escapeRegExp(AGENTS_END_MARKER)}\\n?`);
         writeFileSync(targetPath, existing.replace(pattern, section), 'utf8');
-        return { target: 'agents-md', path: targetPath, action: 'updated' };
+        return { target: 'agents-md', path: targetPath, action: 'updated', mode: 'section' };
     }
     const existingPrefix = existing.trim().length === 0 ? '' : existing;
     const separator = existingPrefix.endsWith('\n') ? '\n' : '\n\n';
     writeFileSync(targetPath, `${existingPrefix}${existingPrefix ? separator : ''}${section}`, 'utf8');
-    return { target: 'agents-md', path: targetPath, action: 'updated' };
+    return { target: 'agents-md', path: targetPath, action: 'updated', mode: 'section' };
 }
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+function pathEntryExists(path) {
+    try {
+        lstatSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export function targetNeedsOverwrite(target, options) {
     const targetPath = getSkillInstallPath(target, options);
+    if (target !== 'agents-md') {
+        return pathEntryExists(targetPath);
+    }
     if (!existsSync(targetPath)) {
         return false;
     }
-    if (target !== 'agents-md') {
-        return true;
-    }
     const existing = readFileSync(targetPath, 'utf8');
     return existing.includes(AGENTS_START_MARKER) && existing.includes(AGENTS_END_MARKER);
 }
+function writeSkillMeta(targetDir, source, options) {
+    const meta = {
+        name: source.name,
+        skillHash: computeSkillContentHash(source.root),
+        cliVersion: options?.cliVersion || null,
+        source: source.source,
+        sourceRoot: source.root,
+        mode: 'copy',
+        installedAt: new Date().toISOString(),
+    };
+    writeFileSync(join(targetDir, SKILL_META_FILENAME), `${JSON.stringify(meta, null, 2)}\n`, 'utf8');
+}
+export function readSkillMeta(targetDir) {
+    const metaPath = join(targetDir, SKILL_META_FILENAME);
+    if (!existsSync(metaPath)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(metaPath, 'utf8'));
+        return parsed && typeof parsed === 'object' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function linkSkillTree(sourceDir, targetDir) {
+    rmSync(targetDir, { recursive: true, force: true });
+    mkdirSync(dirname(targetDir), { recursive: true });
+    symlinkSync(sourceDir, targetDir, 'dir');
+}
 export function installSkillTarget(target, options) {
-    const sourceDir = resolveSkillSourceDir();
+    const source = resolveSkillSource();
     const targetPath = getSkillInstallPath(target, options);
-    const exists = existsSync(targetPath);
     if (target === 'agents-md') {
-        return installAgentsMd(sourceDir, targetPath, options);
+        return installAgentsMd(source.root, targetPath, options);
     }
+    const exists = pathEntryExists(targetPath);
+    const mode = resolveEffectiveInstallMode(target, source.root, options?.mode);
     if (options?.dryRun) {
         return {
             target,
             path: targetPath,
             action: exists ? 'would-update' : 'would-create',
+            mode,
         };
     }
     if (exists && !options?.overwrite) {
         throw new Error(`${targetPath} already exists. Pass --yes to replace it.`);
     }
-    copySkillTree(sourceDir, targetPath);
+    if (mode === 'link') {
+        linkSkillTree(source.root, targetPath);
+    }
+    else {
+        copySkillTree(source.root, targetPath);
+        writeSkillMeta(targetPath, source, options);
+    }
     return {
         target,
         path: targetPath,
         action: exists ? 'updated' : 'created',
+        mode,
+    };
+}
+function getAgentsMdStatus(targetPath, source, sourceHash) {
+    const base = {
+        target: 'agents-md',
+        path: targetPath,
+        mode: 'section',
+        linkTarget: null,
+        installedHash: null,
+        sourceHash,
+        meta: null,
+    };
+    if (!existsSync(targetPath)) {
+        return { ...base, state: 'missing' };
+    }
+    const existing = readFileSync(targetPath, 'utf8');
+    const start = existing.indexOf(AGENTS_START_MARKER);
+    const end = existing.indexOf(AGENTS_END_MARKER);
+    if (start === -1 || end === -1) {
+        return { ...base, state: 'unmanaged' };
+    }
+    const actualSection = existing.slice(start, end + AGENTS_END_MARKER.length);
+    const expectedSection = buildAgentsSection(source.root).trimEnd();
+    return {
+        ...base,
+        state: actualSection.trimEnd() === expectedSection ? 'current' : 'stale',
+    };
+}
+export function getSkillTargetStatus(target, options) {
+    const source = resolveSkillSource();
+    const sourceHash = computeSkillContentHash(source.root);
+    const targetPath = getSkillInstallPath(target, options);
+    if (target === 'agents-md') {
+        return getAgentsMdStatus(targetPath, source, sourceHash);
+    }
+    const base = {
+        target,
+        path: targetPath,
+        linkTarget: null,
+        installedHash: null,
+        sourceHash,
+        meta: null,
+    };
+    if (!pathEntryExists(targetPath)) {
+        return { ...base, state: 'missing', mode: null };
+    }
+    const stats = lstatSync(targetPath);
+    if (stats.isSymbolicLink()) {
+        const linkTarget = readlinkSync(targetPath);
+        if (!existsSync(targetPath)) {
+            return { ...base, state: 'broken-link', mode: 'link', linkTarget };
+        }
+        const resolvedLink = realpathSync(targetPath);
+        const installedHash = computeSkillContentHash(resolvedLink);
+        const state = resolvedLink === realpathSync(source.root) || installedHash === sourceHash
+            ? 'current'
+            : 'stale';
+        return { ...base, state, mode: 'link', linkTarget, installedHash };
+    }
+    const installedHash = computeSkillContentHash(targetPath);
+    const meta = readSkillMeta(targetPath);
+    // A differing directory without our meta file was not installed by Orizu
+    // (or was hand-customized): treat it as unmanaged so `skills update` never
+    // silently overwrites it. Matching content is current regardless of meta.
+    const state = installedHash === sourceHash ? 'current' : meta ? 'stale' : 'unmanaged';
+    return {
+        ...base,
+        state,
+        mode: 'copy',
+        installedHash,
+        meta,
     };
 }
 export function isSkillInstallTarget(value) {

package/dist/task-assignment-manifest.js

@@ -0,0 +1,59 @@
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function parseAssignmentManifestJsonl(content) {
+    // Keep these JSONL field rules in sync with the server's explicitAssignments parser.
+    const entries = [];
+    const lines = content.split(/\r?\n/);
+    lines.forEach((line, lineIndex) => {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch (error) {
+            throw new Error(`Assignment manifest line ${lineIndex + 1} is not valid JSON`);
+        }
+        if (!isRecord(parsed)) {
+            throw new Error(`Assignment manifest line ${lineIndex + 1} must be a JSON object`);
+        }
+        const rowId = typeof parsed.rowId === 'string' ? parsed.rowId.trim() : '';
+        if (!rowId) {
+            throw new Error(`Assignment manifest line ${lineIndex + 1} must include a non-empty rowId`);
+        }
+        const hasAssignee = Object.hasOwn(parsed, 'assignee');
+        const hasAssignees = Object.hasOwn(parsed, 'assignees');
+        if (hasAssignee && hasAssignees) {
+            throw new Error(`Assignment manifest line ${lineIndex + 1} must provide either assignee or assignees, not both`);
+        }
+        if (hasAssignee) {
+            const assignee = typeof parsed.assignee === 'string' ? parsed.assignee.trim() : '';
+            if (!assignee) {
+                throw new Error(`Assignment manifest line ${lineIndex + 1} assignee must be a non-empty string`);
+            }
+            entries.push({ rowId, assignee });
+            return;
+        }
+        if (hasAssignees) {
+            if (!Array.isArray(parsed.assignees) || parsed.assignees.length === 0) {
+                throw new Error(`Assignment manifest line ${lineIndex + 1} assignees must be a non-empty string array`);
+            }
+            parsed.assignees.forEach((assigneeValue, assigneeIndex) => {
+                const assignee = typeof assigneeValue === 'string' ? assigneeValue.trim() : '';
+                if (!assignee) {
+                    throw new Error(`Assignment manifest line ${lineIndex + 1} assignees[${assigneeIndex}] must be a non-empty string`);
+                }
+                entries.push({ rowId, assignee });
+            });
+            return;
+        }
+        throw new Error(`Assignment manifest line ${lineIndex + 1} must include assignee or assignees`);
+    });
+    if (entries.length === 0) {
+        throw new Error('Assignment manifest must contain at least one assignment');
+    }
+    return entries;
+}

package/dist/workspace.js

@@ -0,0 +1,76 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join, resolve } from 'path';
+export const WORKSPACE_DIR_NAME = '.orizu';
+const WORKSPACE_README = `# Orizu workspace
+
+Local Orizu artifacts for this repository. This folder is gitignored by
+default: generated and server-derived content here is not guaranteed to stay
+in sync with the Orizu server, so checking it in would risk drift. Safe,
+user-authored configuration may move to a committed location once a sync model
+exists.
+
+- \`workspace.json\`: safe local metadata (no secrets; credentials stay in
+  \`~/.config/orizu\`).
+- \`generated/\`: runner artifacts, exports, and other generated files.
+`;
+export function getWorkspaceRoot(cwd) {
+    return resolve(cwd || process.cwd(), WORKSPACE_DIR_NAME);
+}
+export function workspaceExists(cwd) {
+    return existsSync(join(getWorkspaceRoot(cwd), 'workspace.json'));
+}
+function ensureGitignoreEntry(cwd, dryRun) {
+    const gitignorePath = resolve(cwd, '.gitignore');
+    const entry = `${WORKSPACE_DIR_NAME}/`;
+    if (existsSync(gitignorePath)) {
+        const existing = readFileSync(gitignorePath, 'utf8');
+        const hasEntry = existing
+            .split('\n')
+            .some(line => line.trim() === entry || line.trim() === WORKSPACE_DIR_NAME);
+        if (hasEntry) {
+            return { updated: false, action: null };
+        }
+        if (!dryRun) {
+            const separator = existing.endsWith('\n') || existing.length === 0 ? '' : '\n';
+            writeFileSync(gitignorePath, `${existing}${separator}\n# Local Orizu workspace (generated; not synced with the server)\n${entry}\n`, 'utf8');
+        }
+        return { updated: true, action: `append ${entry} to .gitignore` };
+    }
+    if (!dryRun) {
+        writeFileSync(gitignorePath, `# Local Orizu workspace (generated; not synced with the server)\n${entry}\n`, 'utf8');
+    }
+    return { updated: true, action: `create .gitignore with ${entry}` };
+}
+export function initOrizuWorkspace(options) {
+    const cwd = resolve(options?.cwd || process.cwd());
+    const root = getWorkspaceRoot(cwd);
+    const dryRun = Boolean(options?.dryRun);
+    const exists = workspaceExists(cwd);
+    const actions = [];
+    if (!exists) {
+        actions.push(`create ${WORKSPACE_DIR_NAME}/workspace.json, README.md, and generated/`);
+    }
+    const gitignore = ensureGitignoreEntry(cwd, dryRun || exists);
+    if (!exists && gitignore.action) {
+        actions.push(gitignore.action);
+    }
+    if (dryRun) {
+        return {
+            root,
+            state: exists ? 'exists' : 'would-create',
+            gitignoreUpdated: false,
+            actions,
+        };
+    }
+    if (exists) {
+        return { root, state: 'exists', gitignoreUpdated: false, actions: [] };
+    }
+    mkdirSync(join(root, 'generated'), { recursive: true });
+    writeFileSync(join(root, 'README.md'), WORKSPACE_README, 'utf8');
+    writeFileSync(join(root, 'workspace.json'), `${JSON.stringify({
+        version: 1,
+        server: options?.baseUrl || null,
+        createdByCliVersion: options?.cliVersion || null,
+    }, null, 2)}\n`, 'utf8');
+    return { root, state: 'created', gitignoreUpdated: gitignore.updated, actions };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orizu",
-  "version": "0.3.7",
+  "version": "0.4.1",
   "private": false,
   "type": "module",
   "bin": {
@@ -27,5 +27,9 @@
     "react": "19.2.6",
     "react-dom": "19.2.6",
     "tailwindcss": "^4.1.10"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "5.8.3"
   }
 }

package/src/banner.ts

@@ -0,0 +1,21 @@
+// Faceted rendering of the Orizu origami swan (public/orizu-swan.svg):
+// each polygon is filled with block/triangle glyphs and shrunk slightly so
+// the seams between origami facets stay visible, matching the brand mark.
+// Printed uncolored so it renders in the terminal's default foreground.
+export const ORIZU_BANNER = `     ▄▄
+   ▄▜▛ ██▙
+  ▟▀   ◥██▛
+        ▀▜▄
+       ▄▟█
+     ▄███
+   ▄████◤        ▄▄▄█▛
+ ▟█████◤     ▄▄█████▛
+ ▄▀███◤  ▄█████████▛
+ ◥█▄▀▛▐█▄◥▜███████▛ ███▀
+  ▜██ ████▄◥▜████▛ ██▀
+   █ ███████▄ ▜█▛ █▀
+    ▐█████████◣  ▀`
+
+export function renderBanner(): string {
+  return ORIZU_BANNER
+}