@chronicle.app/foodnoms 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrew Louis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+# @chronicle.app/foodnoms
+
+Read the FoodNoms app's SQLite database with `FoodNomsExtractor`, then emit one `EatAction` or `DrankAction` per logged food entry with `FoodNomsTransformer`. `input` defaults to `~/Library/Containers/com.algebraiclabs.foodnoms/Data/Documents/db.db`; reading it needs Full Disk Access. The connection is read-only via built-in `node:sqlite`.
+
+```sh
+chronicle extract foodnoms --limit 0
+```
+
+Records are food entries, newest first, joined to their meal slot. `since`/`until` are inclusive bounds on the entry date, and `limit: 0` means unlimited. FoodNoms stores dates as UTC text; the extractor adds a `Z` and turns the entry's blob ID into a dashed UUID.
+
+Each action happens at the entry's `timestamp` and is keyed by the entry's ID without its type. FoodNoms has no food-or-drink flag, so an entry whose name contains a common drink word becomes a `DrankAction`, and anything else an `EatAction`. Keeping the type out of the key lets that guess change without changing the action's identity.
+
+The object is a `Meal` keyed by the same entry ID and named after the food. Its `category` is the meal slot: the built-in slots map to Breakfast, Lunch, Dinner and Snacks, a customized slot uses its own name, and an unnamed custom slot has none. The `description` joins the slot, brand, amount and calories.
+
+The agent is the iCloud account owner from `@chronicle.app/icloud`. An explicit `account` object (or null) describes exported data without a host account lookup.
+
+Tests use a synthetic FoodNoms database with an explicit `account`, so they never read the host's FoodNoms data or iCloud account.

package/dist/connectors/FoodNomsExtractor.d.ts

@@ -0,0 +1,29 @@
+import { Record } from '@chronicle.app/etl';
+import { SqliteExtractor } from '@chronicle.app/etl-sqlite';
+import FoodNomsTransformer from './FoodNomsTransformer.js';
+export declare class FoodNomsExtractor extends SqliteExtractor<typeof FoodNomsExtractor> {
+    static source: string;
+    static strategy: string;
+    static description: string;
+    static recordTypes: string[];
+    static default: boolean;
+    static schema: any;
+    static defaultTransformer: typeof FoodNomsTransformer;
+    /**
+     * `entryID` is a 16-byte CloudKit record UUID stored as a BLOB, so it comes
+     * out of SQLite as `hex(entryID)` (32 hex chars) and is reshaped into the
+     * canonical dashed UUID. (`foodID`/`versionID`/`mealTypeID` are plain TEXT and
+     * must NOT go through here — they are already string identifiers.)
+     */
+    private hexToUuid;
+    /**
+     * FoodNoms stores DATETIME columns as naive `YYYY-MM-DD HH:MM:SS.sss` strings
+     * in UTC (CloudKit sync semantics; `tzID` only records the display zone). The
+     * `since`/`until` config values are real Dates, so format them to that same
+     * shape — a raw `toISOString()` would carry a `T`/`Z` and never compare
+     * correctly against the column's space-separated text.
+     */
+    private toDbDate;
+    extract(): AsyncGenerator<Record>;
+}
+//# sourceMappingURL=FoodNomsExtractor.d.ts.map

package/dist/connectors/FoodNomsExtractor.js

@@ -0,0 +1,159 @@
+import { SqliteExtractor, timeRangeConditions } from '@chronicle.app/etl-sqlite';
+import { getICloudAccount } from '@chronicle.app/icloud';
+import { z } from 'zod';
+import FoodNomsTransformer from './FoodNomsTransformer.js';
+/**
+ * FoodNoms' built-in meal slots. Their names aren't stored in the database (only
+ * user-customized slots get a mealTypeRecord row), so these defaults map the
+ * stock mealTypeID values. Confirmed against this store two ways: id 3 is the
+ * one row that exists and carries an 18:00–22:15 time range (Dinner), and the
+ * per-id entry times line up (id 1 ≈ 09:00, 2 ≈ 12:00, 3 ≈ 19:00, 4 spread).
+ * Custom ids (e.g. 6, 7) have no name anywhere and stay unmapped.
+ */
+const BUILTIN_MEAL_TYPES = {
+    '1': 'Breakfast',
+    '2': 'Lunch',
+    '3': 'Dinner',
+    '4': 'Snacks',
+};
+export class FoodNomsExtractor extends SqliteExtractor {
+    static source = 'foodnoms';
+    static strategy = 'app-db';
+    static description = 'Logged meals';
+    static recordTypes = ['meals'];
+    static default = true;
+    static schema = SqliteExtractor.schema.omit({ input: true }).extend({
+        input: z
+            .string()
+            .describe('Path to the FoodNoms SQLite database file')
+            .default(`${process.env.HOME}/Library/Containers/com.algebraiclabs.foodnoms/Data/Documents/db.db`),
+        account: z
+            .object({
+            accountID: z.string(),
+            email: z.string(),
+            displayName: z.string(),
+            dsid: z.string().optional(),
+        })
+            .nullable()
+            .optional(),
+    }); // Type assertion to override constraint
+    static defaultTransformer = FoodNomsTransformer;
+    /**
+     * `entryID` is a 16-byte CloudKit record UUID stored as a BLOB, so it comes
+     * out of SQLite as `hex(entryID)` (32 hex chars) and is reshaped into the
+     * canonical dashed UUID. (`foodID`/`versionID`/`mealTypeID` are plain TEXT and
+     * must NOT go through here — they are already string identifiers.)
+     */
+    hexToUuid(hex) {
+        if (!hex)
+            return null;
+        const cleaned = hex.toLowerCase();
+        return `${cleaned.slice(0, 8)}-${cleaned.slice(8, 12)}-${cleaned.slice(12, 16)}-${cleaned.slice(16, 20)}-${cleaned.slice(20, 32)}`;
+    }
+    /**
+     * FoodNoms stores DATETIME columns as naive `YYYY-MM-DD HH:MM:SS.sss` strings
+     * in UTC (CloudKit sync semantics; `tzID` only records the display zone). The
+     * `since`/`until` config values are real Dates, so format them to that same
+     * shape — a raw `toISOString()` would carry a `T`/`Z` and never compare
+     * correctly against the column's space-separated text.
+     */
+    toDbDate(date) {
+        return date.toISOString().replace('T', ' ').replace('Z', '');
+    }
+    async *extract() {
+        if (!this.db) {
+            throw new Error('Database not initialized');
+        }
+        const conditions = [`1=1`];
+        const values = [];
+        const range = timeRangeConditions('f.date', this.config, {
+            convert: date => this.toDbDate(date),
+            sinceOp: '>=',
+            untilOp: '<=',
+        });
+        conditions.push(...range.conditions);
+        values.push(...range.values);
+        const limit = this.getEffectiveLimit();
+        if (limit !== null) {
+            values.push(limit);
+        }
+        const query = `
+      SELECT
+        f.id,
+        hex(f.entryID) as entryID,
+        f.date,
+        f.dateCreated,
+        f.dateLastUpdated,
+        f.tzID,
+        f.quantity,
+        f.calories,
+        f.foodID,
+        f.versionID,
+        f.barcode,
+        f.source,
+        f.secondarySource,
+        f.name,
+        f.brandOwner,
+        f.baseUnit,
+        f.baseAmount,
+        f.nutrients,
+        f.mealTypeID,
+        f.day,
+        m.name as mealTypeName,
+        m.timeRangeStart as mealTimeRangeStart,
+        m.timeRangeEnd as mealTimeRangeEnd,
+        m.sortIndex as mealSortIndex
+      FROM foodEntryRecord f
+      LEFT JOIN mealTypeRecord m ON f.mealTypeID = m.mealTypeID
+      WHERE ${conditions.join(' AND ')}
+      ORDER BY f.date DESC
+      ${limit === null ? '' : 'LIMIT ?'}
+    `;
+        const rows = this.db.prepare(query).all(...values);
+        const account = this.config.account === undefined ? await getICloudAccount() : this.config.account;
+        for (const row of rows) {
+            // Parse nutrients JSON if present
+            let nutrients = null;
+            if (row.nutrients) {
+                try {
+                    nutrients = JSON.parse(row.nutrients);
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to parse nutrients JSON: ${error}`);
+                }
+            }
+            // entryID is the only blob UUID; foodID/versionID/mealTypeID are plain
+            // text and pass through untouched. The naive UTC date strings get a 'Z'
+            // so `new Date(...)` reads them as the UTC instants they are.
+            const processedRow = {
+                ...row,
+                entryID: this.hexToUuid(row.entryID),
+                nutrients,
+                date: row.date ? row.date + 'Z' : null,
+                dateCreated: row.dateCreated ? row.dateCreated + 'Z' : null,
+                dateLastUpdated: row.dateLastUpdated ? row.dateLastUpdated + 'Z' : null,
+            };
+            // Resolve the meal slot's name. mealTypeRecord only holds rows the user
+            // has customized (the built-ins live in the app), so the join is usually
+            // empty and we fall back to FoodNoms' built-in id→name defaults. A real
+            // (renamed/custom) name from the join always wins; unknown custom ids
+            // resolve to null rather than a synthesized label.
+            const mealTypeId = row.mealTypeID;
+            const joinName = row.mealTypeName?.trim() || null;
+            const mealTypeName = joinName ?? BUILTIN_MEAL_TYPES[mealTypeId] ?? null;
+            const mealType = mealTypeId
+                ? {
+                    id: mealTypeId,
+                    name: mealTypeName,
+                    timeRangeStart: row.mealTimeRangeStart,
+                    timeRangeEnd: row.mealTimeRangeEnd,
+                    sortIndex: row.mealSortIndex,
+                }
+                : null;
+            yield this.createRecord(processedRow, {
+                mealType,
+                account,
+            });
+        }
+    }
+}

package/dist/connectors/FoodNomsTransformer.d.ts

@@ -0,0 +1,16 @@
+import { ChronicleTransformer, Record } from '@chronicle.app/etl';
+import { ActionAndChildren } from '@chronicle.app/schema';
+export default class FoodNomsTransformer extends ChronicleTransformer {
+    transform(record: Record): Promise<ActionAndChildren[]>;
+    private buildMealActions;
+    /** Coarse, revisable eat-vs-drink inference; see DRINK_WORDS. */
+    private isDrink;
+    /**
+     * FoodNoms is a local single-user app, and the database carries no identity of
+     * its own, so the eater is the device owner — the same iCloud Person the other
+     * macOS plugins resolve, which lets "me" merge across sources.
+     */
+    private buildUser;
+    private buildMeal;
+}
+//# sourceMappingURL=FoodNomsTransformer.d.ts.map

package/dist/connectors/FoodNomsTransformer.js

@@ -0,0 +1,148 @@
+import { ChronicleTransformer } from '@chronicle.app/etl';
+import { buildICloudPersonSchema } from '@chronicle.app/icloud';
+/**
+ * Conservative seed list of common beverages, matched whole-word against an
+ * entry's name. FoodNoms records NO food-vs-drink flag — verified there is no
+ * category column anywhere in the database — so eat-vs-drink can only be
+ * inferred. This list is intentionally coarse and high-precision (it will miss
+ * non-English/brand-name drinks and may catch e.g. "coffee cake"); it is a
+ * placeholder, not truth. The authoritative drink vocabulary is meant to be the
+ * user's own historical `drank X` log: when that data is imported, the set of
+ * objects it labels as drunk should supersede and extend this seed. The action
+ * is keyed without `@type` (see buildMealActions) precisely so this label can be
+ * re-derived without changing a consumption's identity.
+ */
+const DRINK_WORDS = new Set([
+    'water',
+    'coffee',
+    'espresso',
+    'latte',
+    'cappuccino',
+    'americano',
+    'macchiato',
+    'mocha',
+    'frappuccino',
+    'tea',
+    'chai',
+    'matcha',
+    'juice',
+    'soda',
+    'pop',
+    'cola',
+    'lemonade',
+    'kombucha',
+    'smoothie',
+    'milkshake',
+    'milk',
+    'beer',
+    'lager',
+    'ale',
+    'ipa',
+    'stout',
+    'cider',
+    'wine',
+    'prosecco',
+    'champagne',
+    'sake',
+    'cocktail',
+    'margarita',
+    'martini',
+    'mojito',
+    'whiskey',
+    'whisky',
+    'vodka',
+    'gin',
+    'rum',
+    'tequila',
+    'brandy',
+    'liqueur',
+]);
+export default class FoodNomsTransformer extends ChronicleTransformer {
+    async transform(record) {
+        const actions = [];
+        if (record.extraction.recordType === 'meals') {
+            actions.push(...(await this.buildMealActions(record)));
+        }
+        return actions;
+    }
+    async buildMealActions(record) {
+        const meal = this.buildMeal(record.data, record.context);
+        const user = await this.buildUser(record.context.account);
+        // One consume action per logged food entry. FoodNoms gives a single point in
+        // time (`date`), not a span, so it lands on `timestamp` rather than endTime.
+        //
+        // Identity is the consumption of this entry — keyed on the real entryID — and
+        // `@type` is deliberately left OUT of the @key: eat-vs-drink is an inferred,
+        // revisable label (see DRINK_WORDS), so reclassifying must not mint a new
+        // action. This also keeps FoodNoms consumptions shaped like the historical
+        // `ate X` / `drank X` log so the two can sit on one timeline.
+        const shared = {
+            timestamp: record.data.date,
+            '@key': ['source', 'sourceId'],
+            source: 'foodnoms',
+            sourceId: record.data.entryID,
+            agent: user,
+            object: meal,
+        };
+        const action = this.isDrink(record.data.name)
+            ? { '@type': 'DrankAction', ...shared }
+            : { '@type': 'EatAction', ...shared };
+        return [action];
+    }
+    /** Coarse, revisable eat-vs-drink inference; see DRINK_WORDS. */
+    isDrink(name) {
+        if (!name)
+            return false;
+        return name
+            .toLowerCase()
+            .split(/[^a-z]+/)
+            .some(word => DRINK_WORDS.has(word));
+    }
+    /**
+     * FoodNoms is a local single-user app, and the database carries no identity of
+     * its own, so the eater is the device owner — the same iCloud Person the other
+     * macOS plugins resolve, which lets "me" merge across sources.
+     */
+    buildUser(account) {
+        return buildICloudPersonSchema(account);
+    }
+    buildMeal(data, context) {
+        // Key on `entryID`, the per-log CloudKit UUID FoodNoms assigns each entry.
+        // `foodID` looks like a shared food reference but for the dominant namespaces
+        // (`openai:` AI lookups, `local:` manual foods) it is a fresh UUID minted per
+        // entry, so it neither dedupes repeats nor is a real cross-log identity —
+        // using it would elevate a synthetic id to entity identity.
+        const meal = {
+            '@type': 'Meal',
+            '@key': ['@type', 'source', 'sourceId'],
+            source: 'foodnoms',
+            sourceId: data.entryID,
+            name: data.name,
+        };
+        // Classify the meal slot (Breakfast/Lunch/Dinner/Snacks) when known.
+        // `category` is the closed-classification characterization property; the slot
+        // name is resolved upstream (built-in id→name map, or a custom mealTypeRecord
+        // name) and is null for unnamed custom slots, which go uncategorized.
+        if (context.mealType?.name) {
+            meal.category = [context.mealType.name];
+        }
+        // Add meal type name and brand to description if available
+        const descriptions = [];
+        if (context.mealType?.name) {
+            descriptions.push(context.mealType.name);
+        }
+        if (data.brandOwner) {
+            descriptions.push(`Brand: ${data.brandOwner}`);
+        }
+        if (data.quantity && data.baseUnit) {
+            descriptions.push(`${data.quantity} ${data.baseUnit}`);
+        }
+        if (data.calories) {
+            descriptions.push(`${data.calories} calories`);
+        }
+        if (descriptions.length > 0) {
+            meal.description = descriptions.join(' - ');
+        }
+        return meal;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { FoodNomsExtractor } from './connectors/FoodNomsExtractor.js';
+export { default as FoodNomsTransformer } from './connectors/FoodNomsTransformer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,2 @@
+export { FoodNomsExtractor } from './connectors/FoodNomsExtractor.js';
+export { default as FoodNomsTransformer } from './connectors/FoodNomsTransformer.js';

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@chronicle.app/foodnoms",
+  "version": "0.3.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc -b tsconfig.lib.json",
+    "typecheck": "tsc -p tsconfig.json",
+    "lint": "eslint src --ext .ts,.js",
+    "test": "node --test src/*.test.js"
+  },
+  "keywords": [
+    "chronicle",
+    "foodnoms"
+  ],
+  "author": "Andrew Louis",
+  "license": "MIT",
+  "type": "module",
+  "description": "Chronicle plugin for FoodNoms meal tracking data",
+  "devDependencies": {
+    "@chronicle.app/etl": "0.3.0",
+    "@chronicle.app/schema": "0.3.0",
+    "@chronicle.app/tsconfig": "0.3.0",
+    "@types/node": "^22.10.1",
+    "typescript": "^5.7.2"
+  },
+  "homepage": "https://chronicle.app",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chronicle-app/chronicle.git",
+    "directory": "plugins/foodnoms"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@chronicle.app/etl-sqlite": "0.3.0",
+    "@chronicle.app/icloud": "0.3.0",
+    "zod": "^3.24.1"
+  },
+  "peerDependencies": {
+    "@chronicle.app/etl": ">=0.1.0 <1.0.0",
+    "@chronicle.app/schema": ">=0.1.0 <1.0.0"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "chronicle": {
+    "plugin": true,
+    "sources": {
+      "foodnoms": {
+        "strategies": {
+          "app-db": {
+            "delivery": "local",
+            "recordTypes": [
+              "meals"
+            ],
+            "default": true
+          }
+        },
+        "platforms": [
+          "darwin"
+        ]
+      }
+    }
+  }
+}