artifacty 0.10.6 → 0.10.7

package/README.md

@@ -325,6 +325,7 @@ Schema and storage:
 - Bundle artifacts store multiple files or base64 assets as portable JSON.
 - Supported formats are `html`, `markdown`, `text`, `json`, `code`, `svg`, `mermaid`, `react`, `sarif`, `csv`, `image`, and `video`.
 - Native create/import paths infer `html` from HTML documents or fragments when no explicit format is supplied.
+- `sourceAgent` is canonicalized before storage. Aliases such as `claude-code`, `Claude Code`, `github-copilot`, and `gemini-cli` are stored as `claude`, `copilot`, and `gemini`; legacy `unknown` rows are backfilled only when version metadata, audit data, or source-agent tags provide a known agent.
 - Diagram, component, source snippet, analysis report, table, and media assets use `diagram`, `component`, `snippet`, `analysis-report`, `table`, and `asset` artifact types.
 - Copilot/Cursor examples cover PR reviews, screenshots, demo recordings, and visual evidence bundles.
 - See [docs/artifact-schema-v1.md](docs/artifact-schema-v1.md).

package/docs/artifact-schema-v1.md

@@ -50,6 +50,11 @@ Artifacty store. For authenticated central servers this is the personal token
 owner's email; `publisherName` and `publisherUserId` are included when the
 server can map the request to a local user record. Legacy artifacts are
 best-effort backfilled from the first `create` or `import` audit actor.
+Known source-agent aliases are canonicalized before storage. For example,
+`claude-code`, `Claude Code`, and `anthropic` become `claude`;
+`github-copilot` becomes `copilot`; and `gemini-cli` becomes `gemini`.
+Existing `unknown` rows are upgraded only when version metadata, audit data, or
+source-agent tags provide one of the known agent identities.
 
 ## Version Record
 

package/docs/integrations.md

@@ -321,7 +321,7 @@ Supported converter inputs:
 - Gemini: `returnDisplay`, `llmContent`, text blocks, or local markdown/text/json files.
 - Generic: file extension, content type, HTML doctype/fragments, JSON shape, media data URLs, and markdown headings are used to infer format and title. Generic `text/plain` uploads are upgraded to a more specific format, such as `html`, when filename or content makes that clear.
 
-The converter adds `imported` and source-agent tags, preserves the raw content as an immutable Artifacty version, and records source details under `metadata.artifactyImport`.
+The converter canonicalizes source-agent aliases, adds `imported` and source-agent tags, preserves the raw content as an immutable Artifacty version, and records source details under `metadata.artifactyImport`. For example, `claude-code` and `Claude Code` are stored as `claude`.
 
 Fixture examples for Copilot/Cursor PR review, screenshot, demo recording, and
 visual evidence bundle live under `test/fixtures/` and are covered by converter

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "artifacty",
-  "version": "0.10.6",
+  "version": "0.10.7",
   "description": "Local artifact exchange for heterogeneous LLM agents via HTTP and MCP.",
   "type": "module",
   "keywords": [

package/src/lib/agents.js

@@ -0,0 +1,53 @@
+export const KNOWN_SOURCE_AGENTS = new Set([
+  "artifacty",
+  "claude",
+  "codex",
+  "copilot",
+  "cursor",
+  "gemini",
+  "generic",
+  "mcp",
+  "unknown"
+]);
+
+const SOURCE_AGENT_ALIASES = new Map([
+  ["anthropic", "claude"],
+  ["claude-ai", "claude"],
+  ["claude-code", "claude"],
+  ["claude-code-cli", "claude"],
+  ["claude_cli", "claude"],
+  ["github-copilot", "copilot"],
+  ["copilot-chat", "copilot"],
+  ["vscode-copilot", "copilot"],
+  ["vs-code-copilot", "copilot"],
+  ["cursor-ai", "cursor"],
+  ["gemini-cli", "gemini"],
+  ["google", "gemini"],
+  ["openai", "codex"],
+  ["openai-codex", "codex"],
+  ["codex-cli", "codex"],
+  ["chatgpt", "codex"]
+]);
+
+export function normalizeSourceAgent(value, options = {}) {
+  const defaultValue = options.defaultValue ?? "unknown";
+  const allowAuto = options.allowAuto === true;
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized) {
+    return defaultValue;
+  }
+  if (normalized === "auto") {
+    return allowAuto ? "auto" : defaultValue;
+  }
+  const slug = normalized.replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+  const canonical = SOURCE_AGENT_ALIASES.get(normalized) || SOURCE_AGENT_ALIASES.get(slug) || slug;
+  if (KNOWN_SOURCE_AGENTS.has(canonical)) {
+    return canonical;
+  }
+  return canonical || defaultValue;
+}
+
+export function isUnknownSourceAgent(value) {
+  const normalized = normalizeSourceAgent(value, { defaultValue: "unknown" });
+  return normalized === "unknown" || normalized === "generic" || normalized === "auto";
+}

package/src/lib/converters.js

@@ -1,9 +1,9 @@
 import path from "node:path";
 import { createHash } from "node:crypto";
+import { normalizeSourceAgent } from "./agents.js";
 import { ARTIFACT_TYPES, contentTypeForFormat, normalizeFormat } from "./storage.js";
 
 const CONTINUATION_AGENTS = new Set(["codex", "copilot", "cursor"]);
-const KNOWN_AGENTS = new Set(["auto", "artifacty", "claude", "codex", "copilot", "cursor", "gemini", "generic"]);
 
 export function convertAgentArtifact(input = {}) {
   const originalAgent = normalizeAgent(input.agent || input.sourceAgent || input.source_agent || "auto");
@@ -28,8 +28,11 @@ export function convertAgentArtifact(input = {}) {
   if (media) {
     content = media.content;
   }
-  const sourceAgent = optionalString(input.sourceAgent || input.source_agent || decoded.sourceAgent) ||
-    (originalAgent === "auto" ? detectAgent(parsed, fileName) : originalAgent);
+  const explicitSourceAgent = optionalString(input.sourceAgent || input.source_agent || decoded.sourceAgent);
+  const detectedSourceAgent = originalAgent === "auto" ? detectAgent(parsed, fileName) : originalAgent;
+  const sourceAgent = explicitSourceAgent
+    ? normalizeAgent(explicitSourceAgent)
+    : normalizeAgent(detectedSourceAgent || "unknown");
 
   const title =
     optionalString(input.title) ||
@@ -1387,29 +1390,10 @@ function cleanTitle(value) {
 }
 
 function normalizeAgent(value) {
-  const normalized = optionalString(value).toLowerCase();
-  if (!normalized) {
-    return "auto";
-  }
-  if (normalized === "claude-code" || normalized === "anthropic") {
-    return "claude";
-  }
-  if (normalized === "gemini-cli" || normalized === "google") {
-    return "gemini";
-  }
-  if (normalized === "github-copilot" || normalized === "copilot-chat" || normalized === "vscode-copilot" || normalized === "vs-code-copilot") {
-    return "copilot";
-  }
-  if (normalized === "cursor-ai") {
-    return "cursor";
-  }
-  if (normalized === "openai" || normalized === "chatgpt") {
-    return "codex";
-  }
-  if (KNOWN_AGENTS.has(normalized)) {
-    return normalized;
-  }
-  return normalized.replace(/[^a-z0-9-]+/g, "-") || "generic";
+  return normalizeSourceAgent(value, {
+    defaultValue: "auto",
+    allowAuto: true
+  });
 }
 
 function normalizeTags(tags) {

package/src/lib/storage.js

@@ -4,6 +4,7 @@ import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
+import { isUnknownSourceAgent, normalizeSourceAgent } from "./agents.js";
 import { assertNoSecrets, securityConfig } from "./security.js";
 
 export const STORE_VERSION = 4;
@@ -182,7 +183,11 @@ export async function createArtifact(store = createStore(), input = {}) {
 export async function updateArtifact(store = createStore(), id, input = {}) {
   const secretScan = assertNoSecrets(input, securityConfig());
   input = withSecretScan(input, secretScan);
-  const normalized = normalizeArtifactInput(input, { requireContent: true, requireTitle: false });
+  const normalized = normalizeArtifactInput(input, {
+    requireContent: true,
+    requireTitle: false,
+    defaultSourceAgent: ""
+  });
   const db = openDatabase(store);
 
   try {
@@ -252,7 +257,11 @@ export async function updateArtifact(store = createStore(), id, input = {}) {
 export async function replaceArtifactVersion(store = createStore(), id, versionNumber, input = {}) {
   const secretScan = assertNoSecrets(input, securityConfig());
   input = withSecretScan(input, secretScan);
-  const normalized = normalizeArtifactInput(input, { requireContent: true, requireTitle: false });
+  const normalized = normalizeArtifactInput(input, {
+    requireContent: true,
+    requireTitle: false,
+    defaultSourceAgent: ""
+  });
   const targetVersion = Number(versionNumber);
   if (!Number.isInteger(targetVersion) || targetVersion < 1) {
     throw Object.assign(new Error(`Invalid artifact version: ${versionNumber}`), {
@@ -467,7 +476,7 @@ export async function listArtifactsPage(store = createStore(), filters = {}) {
   const query = normalizeOptionalString(filters.query);
   const normalizedQuery = query.toLowerCase();
   const tag = normalizeOptionalString(filters.tag).toLowerCase();
-  const sourceAgent = normalizeOptionalString(filters.sourceAgent).toLowerCase();
+  const sourceAgent = normalizeSourceAgent(filters.sourceAgent, { defaultValue: "" }).toLowerCase();
 
   try {
     if (query && searchIndexAvailable(db)) {
@@ -1250,6 +1259,7 @@ function openDatabase(store) {
   `);
   initializeSchema(db);
   migrateJsonIndex(db, store);
+  normalizeStoredSourceAgents(db, store);
   syncSearchIndexIfEmpty(db, store);
   return db;
 }
@@ -1492,6 +1502,123 @@ function migrateJsonIndex(db, store) {
   });
 }
 
+const INFERABLE_SOURCE_AGENTS = new Set(["claude", "codex", "copilot", "cursor", "gemini"]);
+
+function normalizeStoredSourceAgents(db, store) {
+  const rows = db.prepare(`
+    SELECT id, source_agent, tags_json
+    FROM artifacts
+  `).all();
+  const updateArtifact = db.prepare("UPDATE artifacts SET source_agent = ?, tags_json = ? WHERE id = ?");
+  let changed = false;
+
+  transaction(db, () => {
+    for (const row of rows) {
+      const normalized = normalizeSourceAgent(row.source_agent, { defaultValue: "unknown" });
+      const inferred = isUnknownSourceAgent(normalized)
+        ? inferStoredSourceAgent(db, row)
+        : normalized;
+      const nextSourceAgent = inferred || normalized;
+      const nextTags = normalizeStoredSourceTags(row.tags_json, nextSourceAgent);
+      if (nextSourceAgent !== row.source_agent || nextTags !== row.tags_json) {
+        updateArtifact.run(nextSourceAgent, nextTags, row.id);
+        changed = true;
+      }
+    }
+
+    const auditRows = db.prepare(`
+      SELECT id, source_agent
+      FROM audit_log
+      WHERE source_agent IS NOT NULL
+        AND TRIM(source_agent) != ''
+    `).all();
+    const updateAudit = db.prepare("UPDATE audit_log SET source_agent = ? WHERE id = ?");
+    for (const row of auditRows) {
+      const normalized = normalizeSourceAgent(row.source_agent, { defaultValue: "" });
+      if (normalized && normalized !== row.source_agent) {
+        updateAudit.run(normalized, row.id);
+        changed = true;
+      }
+    }
+  });
+
+  if (changed) {
+    rebuildSearchIndexInDb(db, store);
+  }
+}
+
+function inferStoredSourceAgent(db, artifactRow) {
+  const tagCandidate = firstInferableSourceAgent(parseJson(artifactRow.tags_json, []));
+  if (tagCandidate) {
+    return tagCandidate;
+  }
+
+  const versionRows = db.prepare(`
+    SELECT metadata_json
+    FROM artifact_versions
+    WHERE artifact_id = ?
+    ORDER BY version DESC
+  `).all(artifactRow.id);
+  for (const row of versionRows) {
+    const metadata = parseJson(row.metadata_json, {});
+    const candidate = firstInferableSourceAgent([
+      metadata.sourceAgent,
+      metadata.source_agent,
+      metadata.agent,
+      metadata.artifactyImport?.sourceAgent,
+      metadata.artifactyImport?.originalAgent
+    ]);
+    if (candidate) {
+      return candidate;
+    }
+  }
+
+  const auditRows = db.prepare(`
+    SELECT source_agent
+    FROM audit_log
+    WHERE artifact_id = ?
+      AND source_agent IS NOT NULL
+      AND TRIM(source_agent) != ''
+    ORDER BY created_at DESC
+  `).all(artifactRow.id);
+  return firstInferableSourceAgent(auditRows.map((row) => row.source_agent));
+}
+
+function normalizeStoredSourceTags(tagsJson, sourceAgent) {
+  const tags = parseJson(tagsJson, []);
+  if (!Array.isArray(tags)) {
+    return JSON.stringify([]);
+  }
+  const normalizedTags = [];
+  for (const tag of tags) {
+    const trimmed = normalizeOptionalString(tag);
+    if (!trimmed) {
+      continue;
+    }
+    const canonical = inferableSourceAgent(trimmed);
+    const next = canonical || (trimmed === "unknown" && INFERABLE_SOURCE_AGENTS.has(sourceAgent) ? sourceAgent : trimmed);
+    if (!normalizedTags.includes(next)) {
+      normalizedTags.push(next);
+    }
+  }
+  return JSON.stringify(normalizedTags);
+}
+
+function firstInferableSourceAgent(values) {
+  for (const value of values || []) {
+    const candidate = inferableSourceAgent(value);
+    if (candidate) {
+      return candidate;
+    }
+  }
+  return "";
+}
+
+function inferableSourceAgent(value) {
+  const normalized = normalizeSourceAgent(value, { defaultValue: "" });
+  return INFERABLE_SOURCE_AGENTS.has(normalized) ? normalized : "";
+}
+
 function ensureSearchTable(db) {
   try {
     const existing = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'artifact_search'").get();
@@ -1715,7 +1842,7 @@ function insertArtifactRecord(db, artifact) {
     artifact.title,
     normalizeArtifactType(artifact.artifactType || artifact.artifact_type || "document"),
     normalizeSchemaVersion(artifact.schemaVersion || artifact.schema_version),
-    artifact.sourceAgent || artifact.source_agent || "unknown",
+    normalizeSourceAgent(artifact.sourceAgent || artifact.source_agent, { defaultValue: "unknown" }),
     normalizeOptionalString(artifact.publisherId || artifact.publisher_id) || null,
     normalizeOptionalString(artifact.publisherName || artifact.publisher_name) || null,
     normalizeOptionalString(artifact.publisherUserId || artifact.publisher_user_id) || null,
@@ -1925,7 +2052,9 @@ function normalizeArtifactInput(input, options) {
     contentType: normalizeOptionalString(input.contentType),
     artifactType: normalizeArtifactType(input.artifactType || input.artifact_type || inferArtifactType(input)),
     schemaVersion: normalizeSchemaVersion(input.schemaVersion || input.schema_version),
-    sourceAgent: normalizeOptionalString(input.sourceAgent || input.source_agent || input.agent) || "unknown",
+    sourceAgent: normalizeSourceAgent(input.sourceAgent || input.source_agent || input.agent, {
+      defaultValue: options.defaultSourceAgent ?? "unknown"
+    }),
     tags: normalizeTags(input.tags),
     metadata: normalizeMetadata(input.metadata)
   };