@jini-ai/server 0.0.0-stage → 0.5.0

package/dist/store/projects/sqlite.d.ts

@@ -0,0 +1,161 @@
+/** @module db/projects
+ * CRUD, run-status queries, and awaiting-input detection for the `projects` SQLite table — a
+ * generic workspace/container row-store, not an OD-specific concept. Also queries `messages` and
+ * `conversations` for run-status and input-gate state. Imports only the core/ kernel (SqliteDb,
+ * DbRow); reaches no sibling concern.
+ *
+ * NOTE (neutral port): drops three OD-product columns with no generic engine equivalent —
+ * `skill_id` (OD's agent-skill marketplace selection), `design_system_id` (OD's Design System
+ * feature), and `applied_plugin_snapshot_id` (OD's plugin host). The already-ported
+ * `schema/migrate.ts` projects table was pre-trimmed to match; see that file and `source-map.md`'s
+ * Design Decisions for the same drop list. The kernel-noun exclusion in `extraction-plan.md` §2.1
+ * ("projects... conversations" are not kernel nouns) does not block this module for the same reason
+ * it didn't block `conversations`: `concern-owned storage` is a generic *optional* storage adapter any
+ * consumer may use, not the kernel itself (`@jini-ai/core`/`@jini-ai/daemon` know nothing about this
+ * table) — so "project" here is a de-branded generic workspace/container concept, not OD's model.
+ */
+import type { SqliteDb } from '@jini-ai/db/sqlite';
+import type { DbRow } from '@jini-ai/db/core';
+/**
+ * Returns all projects ordered by most-recently updated first.
+ * @param db - Open SQLite connection.
+ */
+export declare function listProjects({ db }: {
+    db: SqliteDb;
+}): {
+    id: any;
+    name: any;
+    pendingPrompt: any;
+    metadata: any;
+    customInstructions: any;
+    createdAt: number;
+    updatedAt: number;
+}[];
+/**
+ * Returns the most recent run status for each project, keyed by projectId.
+ * Scans messages with a run_status column and collapses to one entry per project,
+ * so callers can render project-level status badges without iterating conversations.
+ * @param db - Open SQLite connection.
+ */
+export declare function listLatestProjectRunStatuses({ db }: {
+    db: SqliteDb;
+}): Map<string, DbRow>;
+/**
+ * Returns the most recent run status for each conversation, keyed by conversationId.
+ * Used to display per-conversation activity state in a project sidebar.
+ * @param db - Open SQLite connection.
+ */
+export declare function listLatestConversationRunStatuses({ db }: {
+    db: SqliteDb;
+}): Map<string, DbRow>;
+/**
+ * Returns the earliest run status for each conversation, keyed by conversationId.
+ * Useful for determining when a conversation's first agent turn began.
+ * @param db - Open SQLite connection.
+ */
+export declare function listFirstConversationRunStatuses({ db }: {
+    db: SqliteDb;
+}): Map<string, DbRow>;
+/**
+ * Returns the most recent run status for each individual run, keyed by runId.
+ * Powers per-run status indicators in a conversation thread.
+ * @param db - Open SQLite connection.
+ */
+export declare function listLatestRunStatuses({ db }: {
+    db: SqliteDb;
+}): Map<string, DbRow>;
+/**
+ * Returns the set of project IDs whose latest form-bearing assistant message contains a
+ * `<question-form>` or `<ask-question>` artifact and has not yet received a user reply.
+ * Form filtering deliberately precedes ranking: a newer plain assistant turn does not consume
+ * an outstanding question. Keep timestamp/position ordering for replies sharing a timestamp.
+ * This is the data source for an "awaiting input" badge on a project list.
+ * @param db - Open SQLite connection.
+ */
+export declare function listProjectsAwaitingInput({ db }: {
+    db: SqliteDb;
+}): Set<any>;
+/**
+ * Returns the set of conversation IDs whose latest form-bearing assistant message contains a
+ * `<question-form>` or `<ask-question>` artifact and has not yet received a user reply.
+ * As in the project query, a newer plain assistant turn leaves an unanswered form outstanding.
+ * @param db - Open SQLite connection.
+ */
+export declare function listConversationsAwaitingInput({ db }: {
+    db: SqliteDb;
+}): Set<any>;
+/**
+ * Fetches a single project by id, or returns null if it does not exist.
+ * @param db - Open SQLite connection.
+ * @param id - Project id.
+ */
+export declare function getProject({ db, id }: {
+    db: SqliteDb;
+    id: string;
+}): {
+    id: any;
+    name: any;
+    pendingPrompt: any;
+    metadata: any;
+    customInstructions: any;
+    createdAt: number;
+    updatedAt: number;
+} | null;
+/**
+ * Inserts a new project row and returns the freshly read, normalized record.
+ * Metadata is serialized to JSON; all nullable fields default to null on omission.
+ * @param db - Open SQLite connection.
+ * @param project - Project fields to insert.
+ */
+export declare function insertProject({ db, project: p }: {
+    db: SqliteDb;
+    project: DbRow;
+}): {
+    id: any;
+    name: any;
+    pendingPrompt: any;
+    metadata: any;
+    customInstructions: any;
+    createdAt: number;
+    updatedAt: number;
+} | null;
+/**
+ * Applies a partial patch to an existing project, preserving all unpatched fields.
+ * Returns null when the project does not exist; otherwise returns the updated record.
+ * updatedAt defaults to Date.now() when the patch omits it.
+ * @param db - Open SQLite connection.
+ * @param id - Project id to update.
+ * @param patch - Fields to overwrite.
+ * @param optional.clock - Host clock port; defaults to Date.now() as before. An explicit updatedAt
+ * wins without reading the clock, so replayed/imported timestamps remain stable.
+ */
+export declare function updateProject({ db, id, patch }: {
+    db: SqliteDb;
+    id: string;
+    patch: DbRow;
+}, optional?: {
+    clock?: {
+        now(): number;
+    };
+}): {
+    id: any;
+    name: any;
+    pendingPrompt: any;
+    metadata: any;
+    customInstructions: any;
+    createdAt: number;
+    updatedAt: number;
+} | null;
+/**
+ * Permanently removes a project row. Cascading deletes for related rows are
+ * handled at the SQLite schema level, not here.
+ * @param db - Open SQLite connection.
+ * @param id - Project id to delete.
+ */
+export declare function deleteProject({ db, id }: {
+    db: SqliteDb;
+    id: string;
+}): void;
+/** Unchanged local host-project schema; no automatic migration at import. */
+export declare const LEGACY_PROJECTS_DDL = "    CREATE TABLE IF NOT EXISTS projects (\n      id TEXT PRIMARY KEY,\n      name TEXT NOT NULL,\n      pending_prompt TEXT,\n      metadata_json TEXT,\n      custom_instructions TEXT,\n      created_at INTEGER NOT NULL,\n      updated_at INTEGER NOT NULL\n    );\n\n";
+//# sourceMappingURL=sqlite.d.ts.map

package/dist/store/projects/sqlite.js

@@ -0,0 +1,328 @@
+/** @internal Column alias list used in every SELECT against the projects table. */
+const PROJECT_COLS = `id, name,
+  pending_prompt AS pendingPrompt,
+  metadata_json AS metadataJson,
+  custom_instructions AS customInstructions,
+  created_at AS createdAt,
+  updated_at AS updatedAt`;
+/**
+ * Returns all projects ordered by most-recently updated first.
+ * @param db - Open SQLite connection.
+ */
+export function listProjects({ db }) {
+    const rows = db
+        .prepare(`SELECT ${PROJECT_COLS}
+         FROM projects
+        ORDER BY updated_at DESC`)
+        .all();
+    return rows.map(normalizeProject);
+}
+/**
+ * Returns the most recent run status for each project, keyed by projectId.
+ * Scans messages with a run_status column and collapses to one entry per project,
+ * so callers can render project-level status badges without iterating conversations.
+ * @param db - Open SQLite connection.
+ */
+export function listLatestProjectRunStatuses({ db }) {
+    const rows = db
+        .prepare(`SELECT c.project_id AS projectId,
+              m.run_id AS runId,
+              m.run_status AS status,
+              COALESCE(m.ended_at, m.started_at, m.created_at) AS updatedAt
+         FROM messages m
+         JOIN conversations c ON c.id = m.conversation_id
+        WHERE m.run_status IS NOT NULL
+        ORDER BY updatedAt DESC`)
+        .all();
+    const latestByProject = new Map();
+    for (const row of rows) {
+        if (!latestByProject.has(row.projectId)) {
+            latestByProject.set(row.projectId, {
+                value: normalizeProjectRunStatus(row.status),
+                updatedAt: Number(row.updatedAt),
+                runId: row.runId ?? undefined,
+            });
+        }
+    }
+    return latestByProject;
+}
+/**
+ * Returns the most recent run status for each conversation, keyed by conversationId.
+ * Used to display per-conversation activity state in a project sidebar.
+ * @param db - Open SQLite connection.
+ */
+export function listLatestConversationRunStatuses({ db }) {
+    const rows = db
+        .prepare(`SELECT m.conversation_id AS conversationId,
+              m.run_id AS runId,
+              m.run_status AS status,
+              COALESCE(m.ended_at, m.started_at, m.created_at) AS updatedAt,
+              m.position AS position
+         FROM messages m
+        WHERE m.run_status IS NOT NULL
+        ORDER BY updatedAt DESC, m.position DESC`)
+        .all();
+    const latestByConversation = new Map();
+    for (const row of rows) {
+        if (!latestByConversation.has(row.conversationId)) {
+            latestByConversation.set(row.conversationId, {
+                value: normalizeProjectRunStatus(row.status),
+                updatedAt: Number(row.updatedAt),
+                runId: row.runId ?? undefined,
+            });
+        }
+    }
+    return latestByConversation;
+}
+/**
+ * Returns the earliest run status for each conversation, keyed by conversationId.
+ * Useful for determining when a conversation's first agent turn began.
+ * @param db - Open SQLite connection.
+ */
+export function listFirstConversationRunStatuses({ db }) {
+    const rows = db
+        .prepare(`SELECT m.conversation_id AS conversationId,
+              m.run_id AS runId,
+              m.run_status AS status,
+              COALESCE(m.ended_at, m.started_at, m.created_at) AS updatedAt,
+              m.position AS position
+         FROM messages m
+        WHERE m.run_status IS NOT NULL
+          AND m.run_id IS NOT NULL
+        ORDER BY m.position ASC`)
+        .all();
+    const firstByConversation = new Map();
+    for (const row of rows) {
+        if (!firstByConversation.has(row.conversationId)) {
+            firstByConversation.set(row.conversationId, {
+                value: normalizeProjectRunStatus(row.status),
+                updatedAt: Number(row.updatedAt),
+                runId: row.runId ?? undefined,
+            });
+        }
+    }
+    return firstByConversation;
+}
+/**
+ * Returns the most recent run status for each individual run, keyed by runId.
+ * Powers per-run status indicators in a conversation thread.
+ * @param db - Open SQLite connection.
+ */
+export function listLatestRunStatuses({ db }) {
+    const rows = db
+        .prepare(`SELECT m.run_id AS runId,
+              m.run_status AS status,
+              COALESCE(m.ended_at, m.started_at, m.created_at) AS updatedAt,
+              m.position AS position
+         FROM messages m
+        WHERE m.run_status IS NOT NULL
+          AND m.run_id IS NOT NULL
+        ORDER BY updatedAt DESC, m.position DESC`)
+        .all();
+    const latestByRun = new Map();
+    for (const row of rows) {
+        if (!latestByRun.has(row.runId)) {
+            latestByRun.set(row.runId, {
+                value: normalizeProjectRunStatus(row.status),
+                updatedAt: Number(row.updatedAt),
+                runId: row.runId ?? undefined,
+            });
+        }
+    }
+    return latestByRun;
+}
+/**
+ * Returns the set of project IDs whose latest form-bearing assistant message contains a
+ * `<question-form>` or `<ask-question>` artifact and has not yet received a user reply.
+ * Form filtering deliberately precedes ranking: a newer plain assistant turn does not consume
+ * an outstanding question. Keep timestamp/position ordering for replies sharing a timestamp.
+ * This is the data source for an "awaiting input" badge on a project list.
+ * @param db - Open SQLite connection.
+ */
+export function listProjectsAwaitingInput({ db }) {
+    const rows = db
+        .prepare(`SELECT latest.projectId
+         FROM (
+           SELECT c.project_id AS projectId,
+                  m.conversation_id AS conversationId,
+                  m.created_at AS createdAt,
+                  m.position AS position,
+                  ROW_NUMBER() OVER (
+                    PARTITION BY c.project_id
+                    ORDER BY m.created_at DESC, m.position DESC
+                  ) AS rowNum
+             FROM messages m
+             JOIN conversations c ON c.id = m.conversation_id
+            WHERE m.role = 'assistant'
+              -- ask-question is an accepted alias for question-form (host UI parser
+              -- + agent open-tag matcher), so an alias-form turn must also count as
+              -- awaiting input.
+              AND (
+                LOWER(m.content) LIKE '%<question-form%'
+                OR LOWER(m.content) LIKE '%<ask-question%'
+              )
+         ) latest
+        WHERE latest.rowNum = 1
+          AND NOT EXISTS (
+            SELECT 1
+              FROM messages reply
+             WHERE reply.conversation_id = latest.conversationId
+               AND reply.role = 'user'
+               AND (
+                 reply.created_at > latest.createdAt
+                 OR (reply.created_at = latest.createdAt AND reply.position > latest.position)
+               )
+          )`)
+        .all();
+    return new Set(rows.map((row) => row.projectId));
+}
+/**
+ * Returns the set of conversation IDs whose latest form-bearing assistant message contains a
+ * `<question-form>` or `<ask-question>` artifact and has not yet received a user reply.
+ * As in the project query, a newer plain assistant turn leaves an unanswered form outstanding.
+ * @param db - Open SQLite connection.
+ */
+export function listConversationsAwaitingInput({ db }) {
+    const rows = db
+        .prepare(`SELECT latest.conversationId
+         FROM (
+           SELECT m.conversation_id AS conversationId,
+                  m.created_at AS createdAt,
+                  m.position AS position,
+                  ROW_NUMBER() OVER (
+                    PARTITION BY m.conversation_id
+                    ORDER BY m.created_at DESC, m.position DESC
+                  ) AS rowNum
+             FROM messages m
+            WHERE m.role = 'assistant'
+              AND (
+                LOWER(m.content) LIKE '%<question-form%'
+                OR LOWER(m.content) LIKE '%<ask-question%'
+              )
+         ) latest
+        WHERE latest.rowNum = 1
+          AND NOT EXISTS (
+            SELECT 1
+              FROM messages reply
+             WHERE reply.conversation_id = latest.conversationId
+               AND reply.role = 'user'
+               AND (
+                 reply.created_at > latest.createdAt
+                 OR (reply.created_at = latest.createdAt AND reply.position > latest.position)
+               )
+          )`)
+        .all();
+    return new Set(rows.map((row) => row.conversationId));
+}
+/**
+ * Fetches a single project by id, or returns null if it does not exist.
+ * @param db - Open SQLite connection.
+ * @param id - Project id.
+ */
+export function getProject({ db, id }) {
+    const row = db
+        .prepare(`SELECT ${PROJECT_COLS} FROM projects WHERE id = ?`)
+        .get(id);
+    return row ? normalizeProject(row) : null;
+}
+/**
+ * Inserts a new project row and returns the freshly read, normalized record.
+ * Metadata is serialized to JSON; all nullable fields default to null on omission.
+ * @param db - Open SQLite connection.
+ * @param project - Project fields to insert.
+ */
+export function insertProject({ db, project: p }) {
+    db.prepare(`INSERT INTO projects
+       (id, name, pending_prompt, metadata_json, custom_instructions, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`).run(p.id, p.name, p.pendingPrompt ?? null, p.metadata ? JSON.stringify(p.metadata) : null, p.customInstructions ?? null, p.createdAt, p.updatedAt);
+    return getProject({ db, id: p.id });
+}
+/**
+ * Applies a partial patch to an existing project, preserving all unpatched fields.
+ * Returns null when the project does not exist; otherwise returns the updated record.
+ * updatedAt defaults to Date.now() when the patch omits it.
+ * @param db - Open SQLite connection.
+ * @param id - Project id to update.
+ * @param patch - Fields to overwrite.
+ * @param optional.clock - Host clock port; defaults to Date.now() as before. An explicit updatedAt
+ * wins without reading the clock, so replayed/imported timestamps remain stable.
+ */
+export function updateProject({ db, id, patch }, optional = {}) {
+    const existing = getProject({ db, id });
+    if (!existing)
+        return null;
+    const merged = {
+        ...existing,
+        ...patch,
+        updatedAt: typeof patch.updatedAt === 'number' ? patch.updatedAt : (optional.clock ?? Date).now(),
+    };
+    db.prepare(`UPDATE projects
+        SET name = ?,
+            pending_prompt = ?,
+            metadata_json = ?,
+            custom_instructions = ?,
+            updated_at = ?
+      WHERE id = ?`).run(merged.name, merged.pendingPrompt ?? null, merged.metadata ? JSON.stringify(merged.metadata) : null, merged.customInstructions ?? null, merged.updatedAt, id);
+    return getProject({ db, id });
+}
+/**
+ * Permanently removes a project row. Cascading deletes for related rows are
+ * handled at the SQLite schema level, not here.
+ * @param db - Open SQLite connection.
+ * @param id - Project id to delete.
+ */
+export function deleteProject({ db, id }) {
+    db.prepare(`DELETE FROM projects WHERE id = ?`).run(id);
+}
+/** @internal Converts a raw SQLite row into the typed project shape, parsing
+ *  metadataJson and casting numeric timestamps. */
+function normalizeProject(row) {
+    let metadata;
+    if (row.metadataJson) {
+        try {
+            metadata = JSON.parse(row.metadataJson);
+        }
+        catch {
+            metadata = undefined;
+        }
+    }
+    return {
+        id: row.id,
+        name: row.name,
+        pendingPrompt: row.pendingPrompt ?? undefined,
+        metadata,
+        customInstructions: row.customInstructions ?? undefined,
+        createdAt: Number(row.createdAt),
+        updatedAt: Number(row.updatedAt),
+    };
+}
+/** @internal Maps raw DB run_status strings to the canonical client-facing enum,
+ *  collapsing 'starting' → 'running' and 'cancelled' → 'canceled', and defaulting
+ *  unknown values to 'not_started'. */
+function normalizeProjectRunStatus(status) {
+    if (status === 'starting')
+        return 'running';
+    if (status === 'cancelled')
+        return 'canceled';
+    if (status === 'queued' ||
+        status === 'running' ||
+        status === 'succeeded' ||
+        status === 'failed' ||
+        status === 'canceled') {
+        return status;
+    }
+    return 'not_started';
+}
+/** Unchanged local host-project schema; no automatic migration at import. */
+export const LEGACY_PROJECTS_DDL = `    CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      pending_prompt TEXT,
+      metadata_json TEXT,
+      custom_instructions TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+`;
+//# sourceMappingURL=sqlite.js.map

package/package.json

@@ -1,6 +1,89 @@
 {
   "name": "@jini-ai/server",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.5.0",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AINSEP/Jini.git",
+    "directory": "packages/node-host"
+  },
+  "jini": {
+    "domain": "server",
+    "kind": "host",
+    "runtime": "node",
+    "admission": "locked"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./storage": {
+      "types": "./dist/storage/index.d.ts",
+      "import": "./dist/storage/index.js",
+      "default": "./dist/storage/index.js"
+    },
+    "./storage/legacy/sqlite": {
+      "types": "./dist/storage/legacy/sqlite.d.ts",
+      "import": "./dist/storage/legacy/sqlite.js",
+      "default": "./dist/storage/legacy/sqlite.js"
+    },
+    "./store/projects/sqlite": {
+      "types": "./dist/store/projects/sqlite.d.ts",
+      "import": "./dist/store/projects/sqlite.js",
+      "default": "./dist/store/projects/sqlite.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map",
+    "!dist/**/__tests__/**",
+    "!dist/**/*.typecheck.*"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "dependencies": {
+    "express": "^4.21.0",
+    "@jini-ai/agent-runtime": "0.4.0",
+    "@jini-ai/core": "0.4.0",
+    "@jini-ai/http-kit": "0.4.0",
+    "@jini-ai/daemon": "0.5.0",
+    "@jini-ai/sidecar": "0.4.0",
+    "@jini-ai/db": "0.2.0",
+    "@jini-ai/registry": "0.5.0",
+    "@jini-ai/chat": "0.5.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.11",
+    "@types/express": "^4.17.21",
+    "@vitest/coverage-v8": "^2.1.9",
+    "better-sqlite3": "^13.0.0"
+  },
+  "peerDependencies": {
+    "better-sqlite3": "^13.0.0"
+  },
+  "peerDependenciesMeta": {
+    "better-sqlite3": {
+      "optional": true
+    }
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  }
 }