@agentionai/fieldwork-cli 0.4.0 → 0.7.0

package/dist/select.js

@@ -0,0 +1,124 @@
+const operators = ['!=', '>=', '<=', '=', '>', '<'];
+const sectionNames = [
+    'parameters',
+    'observations',
+    'comparisonContext',
+    'extras',
+    'inputRefs',
+    'environment',
+];
+const searched = ['parameters', 'observations', 'comparisonContext', 'extras'];
+export function fail(message, hint) {
+    throw Object.assign(new Error(message), { code: 'INVALID_SELECTION', hint });
+}
+function object(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+// Schema sections are named the same everywhere; a run stores its parameters under `config`. Servers
+// older than the top-level echo only nest the other sections under `research`.
+function section(kind, row, name) {
+    if (name === 'parameters' && kind === 'runs')
+        return object(row['config']);
+    return object(row[name] === undefined ? object(row['research'])[name] : row[name]);
+}
+function walk(value, path) {
+    return path.reduce((current, key) => current && typeof current === 'object'
+        ? current[key]
+        : undefined, value);
+}
+export function resolve(kind, row, path) {
+    const parts = path.split('.');
+    const head = parts[0];
+    if (parts.length > 1 && sectionNames.includes(head))
+        return walk(section(kind, row, head), parts.slice(1));
+    if (Object.hasOwn(row, head))
+        return walk(row, parts);
+    const research = object(row['research']);
+    if (Object.hasOwn(research, head))
+        return walk(research, parts);
+    if (parts.length > 1)
+        return undefined;
+    const found = searched.filter((name) => Object.hasOwn(section(kind, row, name), head));
+    if (found.length > 1)
+        fail(`Ambiguous field '${head}': ${found.map((name) => `${name}.${head}`).join(', ')}`, 'Qualify the field with its section, for example parameters.variant.');
+    return found.length ? section(kind, row, found[0])[head] : undefined;
+}
+export function parseCondition(expression) {
+    for (let index = 0; index < expression.length; index += 1) {
+        const operator = operators.find((candidate) => expression.startsWith(candidate, index));
+        if (!operator)
+            continue;
+        const path = expression.slice(0, index).trim();
+        if (!path)
+            break;
+        return { path, operator, operand: expression.slice(index + operator.length).trim() };
+    }
+    return fail(`Cannot read --where '${expression}'`, "Use FIELD=VALUE, or one of != >= <= > <, for example --where 'parameters.n>=4'.");
+}
+function equals(value, operand) {
+    if (value === undefined)
+        return operand === '';
+    if (typeof value === 'number')
+        return Number(operand) === value && operand.trim() !== '';
+    if (typeof value === 'boolean')
+        return String(value) === operand;
+    if (typeof value === 'string')
+        return value === operand;
+    if (value === null)
+        return operand === 'null';
+    return JSON.stringify(value) === operand;
+}
+export function matches(value, condition) {
+    if (condition.operator === '=')
+        return equals(value, condition.operand);
+    if (condition.operator === '!=')
+        return !equals(value, condition.operand);
+    if (value === undefined || value === null)
+        return false;
+    const numeric = typeof value === 'number' &&
+        condition.operand.trim() !== '' &&
+        Number.isFinite(Number(condition.operand));
+    const [left, right] = numeric
+        ? [value, Number(condition.operand)]
+        : [String(value), condition.operand];
+    return condition.operator === '>'
+        ? left > right
+        : condition.operator === '>='
+            ? left >= right
+            : condition.operator === '<'
+                ? left < right
+                : left <= right;
+}
+// A path that resolves nowhere in a nonempty result is a typo, not an empty column: say so instead of
+// printing a silent blank that a reader would take for a measured absence.
+function requirePresent(kind, rows, paths, flag) {
+    for (const path of paths) {
+        if (rows.length && rows.every((row) => resolve(kind, row, path) === undefined))
+            fail(`No record has ${flag} field '${path}'`, 'Check the spelling and section, or list one record in full to see the available fields.');
+    }
+}
+export function filterRows(kind, rows, conditions) {
+    requirePresent(kind, rows, conditions.map((condition) => condition.path), '--where');
+    return rows.filter((row) => conditions.every((condition) => matches(resolve(kind, row, condition.path), condition)));
+}
+export function projectRows(kind, rows, fields) {
+    requirePresent(kind, rows, fields, '--fields');
+    return rows.map((row) => Object.fromEntries(fields.map((path) => [path, resolve(kind, row, path)])));
+}
+function cell(value) {
+    if (value === undefined)
+        return '';
+    const text = typeof value === 'string' ? value : (JSON.stringify(value) ?? '');
+    return text.replace(/\\/g, '\\\\').replace(/\t/g, '\\t').replace(/\r?\n/g, '\\n');
+}
+export function toTsv(rows, fields) {
+    const columns = fields.length
+        ? [...fields]
+        : [...new Set(rows.flatMap((row) => Object.keys(row)))];
+    return [
+        columns.join('\t'),
+        ...rows.map((row) => columns.map((column) => cell(row[column])).join('\t')),
+    ].join('\n');
+}

package/dist/workspace.js

@@ -1,10 +1,17 @@
-import { lstatSync, mkdirSync, readFileSync, writeFileSync, appendFileSync, unlinkSync, rmdirSync } from 'node:fs';
+import { lstatSync, mkdirSync, readFileSync, writeFileSync, appendFileSync, unlinkSync, rmdirSync, } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
-import { request } from './client.js';
-export function fail(message) { throw new Error(message); }
+import { request, requestAll } from './client.js';
+export function fail(message) {
+    throw new Error(message);
+}
 export function origin(value) {
     const url = new URL(value);
-    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash || url.pathname !== '/')
+    if (!['http:', 'https:'].includes(url.protocol) ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash ||
+        url.pathname !== '/')
         fail('Server URL must be an HTTP(S) origin without credentials or a resource path');
     return url.origin;
 }
@@ -22,7 +29,10 @@ function ref(value) {
     if (!value || typeof value !== 'object')
         return false;
     const r = value;
-    return typeof r.id === 'string' && /^[0-9a-f-]{36}$/i.test(r.id) && typeof r.stub === 'string' && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(r.stub);
+    return (typeof r.id === 'string' &&
+        /^[0-9a-f-]{36}$/i.test(r.id) &&
+        typeof r.stub === 'string' &&
+        /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(r.stub));
 }
 function configDirectory(root) {
     if (stat(join(root, '.fieldwork')))
@@ -41,7 +51,11 @@ export function readWorkspace(root) {
     if (!info.isFile() || info.isSymbolicLink())
         fail('Workspace config must be a regular file');
     const data = JSON.parse(readFileSync(path, 'utf8'));
-    if (!data || data.version !== 1 || !ref(data.campaign) || !(data.product === null || ref(data.product)) || typeof data.serverUrl !== 'string')
+    if (!data ||
+        data.version !== 1 ||
+        !ref(data.campaign) ||
+        !(data.product === null || ref(data.product)) ||
+        typeof data.serverUrl !== 'string')
         fail('Invalid workspace config');
     origin(data.serverUrl);
     return data;
@@ -58,8 +72,10 @@ export function discover(cwd = process.cwd()) {
         root = parent;
     }
 }
-export async function records(url, path) {
-    const data = await request(url, path);
+export async function records(url, path, credentials = {}) {
+    // Paged or not: a collection that answers with a page is walked, because resolving a
+    // stub against the first fifty rows would fail on the fifty-first record someone made.
+    const data = await requestAll(url, path, credentials);
     if (!Array.isArray(data) || !data.every(ref))
         fail('Invalid record collection returned by server');
     return data;
@@ -70,7 +86,7 @@ export function select(items, reference) {
         fail(matches.length ? `Ambiguous reference: ${reference}` : `Record not found: ${reference}`);
     return matches[0];
 }
-export async function setupCampaign(url, options, cwd = process.cwd()) {
+export async function setupCampaign(url, options, cwd = process.cwd(), credentials = {}) {
     url = origin(url);
     const root = resolve(cwd);
     const directory = configDirectory(root);
@@ -104,9 +120,9 @@ export async function setupCampaign(url, options, cwd = process.cwd()) {
         fail('Already inside a campaign workspace; setup must run at its root');
     if (existing && existing.serverUrl !== url)
         fail('Workspace is bound to another server; refusing to rebind');
-    const products = await records(url, '/products');
+    const products = await records(url, '/products', credentials);
     const product = options.product ? select(products, options.product) : undefined;
-    const campaigns = await records(url, '/campaigns');
+    const campaigns = await records(url, '/campaigns', credentials);
     let campaign;
     if (existing && [existing.campaign.id, existing.campaign.stub].includes(options.campaign)) {
         campaign = select(campaigns, existing.campaign.id);
@@ -120,7 +136,12 @@ export async function setupCampaign(url, options, cwd = process.cwd()) {
                 fail('--create requires --goal');
             if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(options.campaign))
                 fail('A new campaign requires a valid stub');
-            campaign = await request(url, '/campaigns', 'POST', { name: options.campaign, stub: options.campaign, goal: options.goal, ...(product ? { productId: product.id } : {}) });
+            campaign = (await request(url, '/campaigns', 'POST', {
+                name: options.campaign,
+                stub: options.campaign,
+                goal: options.goal,
+                ...(product ? { productId: product.id } : {}),
+            }, credentials));
             if (!ref(campaign))
                 fail('Invalid campaign returned by server');
         }
@@ -130,8 +151,14 @@ export async function setupCampaign(url, options, cwd = process.cwd()) {
     if (product && campaign.productId !== product.id)
         fail('Campaign does not belong to the selected product');
     const parent = campaign.productId ? select(products, campaign.productId) : null;
-    const config = { version: 1, serverUrl: url, product: parent ? { id: parent.id, stub: parent.stub } : null, campaign: { id: campaign.id, stub: campaign.stub } };
-    if (existing && (existing.campaign.id !== campaign.id || existing.product?.id !== config.product?.id))
+    const config = {
+        version: 1,
+        serverUrl: url,
+        product: parent ? { id: parent.id, stub: parent.stub } : null,
+        campaign: { id: campaign.id, stub: campaign.stub },
+    };
+    if (existing &&
+        (existing.campaign.id !== campaign.id || existing.product?.id !== config.product?.id))
         fail('Workspace is already bound; refusing to rebind');
     const createdDirs = [];
     const createdFiles = [];
@@ -185,18 +212,36 @@ export async function setupCampaign(url, options, cwd = process.cwd()) {
             try {
                 rmdirSync(path);
             }
-            catch { /* Leave directories containing concurrent user files. */ }
+            catch {
+                /* Leave directories containing concurrent user files. */
+            }
         }
         throw error;
     }
     return { root, config: existing ?? config, created: !existing };
 }
+/** Resolving a stub or an id to a record, against one server.
+ *
+ * Every lookup here sends the caller's credentials. It is the same collection the command
+ * itself would read, so omitting them made every ref-taking command -- update, delete,
+ * record, get -- fail with 401 against a server that authenticates, while the same
+ * credential worked for a plain list.
+ */
+/** The hosted service. A local server is the exception now, and says so with --url,
+ *  FIELDWORK_URL, or the workspace it was set up against. */
+export const DEFAULT_SERVER = 'https://app.fieldworkledger.com';
 export class Scope {
     workspace;
     url;
-    constructor(url, cwd = process.cwd()) {
+    credentials;
+    constructor(url, cwd = process.cwd(), credentials = {}) {
+        this.credentials = credentials;
         this.workspace = discover(cwd);
-        this.url = origin(url ?? process.env['FIELDWORK_URL'] ?? process.env['LAB_URL'] ?? this.workspace?.config.serverUrl ?? 'http://127.0.0.1:4310');
+        this.url = origin(url ??
+            process.env['FIELDWORK_URL'] ??
+            process.env['LAB_URL'] ??
+            this.workspace?.config.serverUrl ??
+            DEFAULT_SERVER);
     }
     local() {
         if (this.workspace && this.url !== this.workspace.config.serverUrl)
@@ -204,13 +249,13 @@ export class Scope {
         return this.workspace?.config;
     }
     async product(reference) {
-        return select(await records(this.url, '/products'), reference);
+        return select(await records(this.url, '/products', this.credentials), reference);
     }
     async campaign(reference) {
         const target = reference ?? this.local()?.campaign.id;
         if (!target)
             fail('Supply --campaign or run setup campaign first');
-        const campaign = select(await records(this.url, '/campaigns'), target);
+        const campaign = select(await records(this.url, '/campaigns', this.credentials), target);
         if (!reference && campaign.productId !== this.local()?.product?.id)
             fail('Campaign parent changed; inspect workspace binding');
         return campaign;
@@ -219,10 +264,15 @@ export class Scope {
         if (!campaignRef && !this.workspace && /^[0-9a-f-]{36}$/i.test(reference))
             return reference;
         const campaign = await this.campaign(campaignRef);
-        return select(await records(this.url, `/campaigns/${campaign.id}/${kind}`), reference).id;
+        return select(await records(this.url, `/campaigns/${campaign.id}/${kind}`, this.credentials), reference).id;
     }
     async context(reference) {
         const campaign = await this.campaign(reference);
-        return { root: this.workspace?.root, serverUrl: this.url, campaign, detail: await request(this.url, `/campaigns/${campaign.id}`) };
+        return {
+            root: this.workspace?.root,
+            serverUrl: this.url,
+            campaign,
+            detail: await request(this.url, `/campaigns/${campaign.id}`, 'GET', undefined, this.credentials),
+        };
     }
 }

package/package.json

@@ -1,17 +1,37 @@
 {
   "name": "@agentionai/fieldwork-cli",
-  "version": "0.4.0",
+  "version": "0.7.0",
   "description": "Agention Fieldwork CLI for research campaigns, experiments and run records",
-  "files": ["dist/main.js", "dist/client.js", "dist/workspace.js", "dist/fieldwork-skill.md"],
-  "engines": { "node": ">=22" },
-  "publishConfig": { "access": "public" },
+  "files": [
+    "dist/main.js",
+    "dist/client.js",
+    "dist/credentials.js",
+    "dist/workspace.js",
+    "dist/select.js",
+    "dist/changelog.js",
+    "dist/fieldwork-skill.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "type": "module",
-  "bin": { "fieldwork": "dist/main.js" },
+  "bin": {
+    "fieldwork": "dist/main.js"
+  },
   "scripts": {
     "build": "tsc -b tsconfig.json --force && node scripts/copy-skill.mjs",
     "prepack": "npm run build",
     "dev": "tsx src/main.ts"
   },
-  "dependencies": { "commander": "^13.1.0" },
-  "devDependencies": { "tsx": "^4.19.2" }
+  "dependencies": {
+    "commander": "^13.1.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12",
+    "better-sqlite3": "^11.7.0",
+    "tsx": "^4.19.2"
+  }
 }