Llama 3.2 1B reads your
+ repository's README and drafts the fields that could not be worked out from the
+ repository metadata alone. It runs entirely on your computer so nothing is sent to
+ any server. The first run downloads about 880 MB and caches it for later visits, so keep
+ this tab open while it loads.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Review AI drafts
+
These are drafted by the model, not read from your
+ repository. Uncheck anything you do not want, edit the text, then apply.
+ Verify every value before you submit.
+
+
+
+
+
+
diff --git a/js/ai/aiContext.js b/js/ai/aiContext.js
new file mode 100644
index 0000000..3bf3a57
--- /dev/null
+++ b/js/ai/aiContext.js
@@ -0,0 +1,202 @@
+// gathers everything the AI suggestions need to know about a repository.
+(function () {
+ const contextCache = new Map();
+
+ function getGitHubToken() {
+ try {
+ const value = window.formIOInstance.getComponent("gh_api_key").getValue();
+ if (value && String(value).trim()) {
+ return String(value).trim();
+ }
+ } catch (error) {}
+ return window.gh_api_key || null;
+ }
+
+ function ghHeaders(accept) {
+ const headers = { "X-GitHub-Api-Version": "2022-11-28" };
+
+ if (accept) {
+ headers.Accept = accept;
+ }
+
+ const token = getGitHubToken();
+ if (token) {
+ headers.Authorization = `Bearer ${token}`;
+ }
+
+ return { headers };
+ }
+
+ function checkRateLimit(response) {
+ const remaining = Number(response.headers.get("x-ratelimit-remaining"));
+
+ if (!Number.isFinite(remaining) || remaining > 10 || getGitHubToken()) {
+ return;
+ }
+
+ window.showErrorNotification(
+ `GitHub API: ${remaining} requests left this hour. Add a GitHub API Key at ` +
+ `the bottom of the form to raise the limit from 60 to 5,000.`
+ );
+ }
+
+ async function getReadme(repoInfo) {
+ const endpoint = `https://api.github.com/repos/${repoInfo.organization}/${repoInfo.repository}/readme`;
+
+ try {
+ const response = await fetch(endpoint, ghHeaders("application/vnd.github.raw"));
+
+ // 404 just means the repository has no README
+ if (!response.ok) {
+ return "";
+ }
+
+ const contentType = response.headers.get("content-type") || "";
+ if (!contentType.includes("json")) {
+ return await response.text();
+ }
+
+ const payload = await response.json();
+ const encoded = (payload.content || "").replace(/\s/g, "");
+ const bytes = Uint8Array.from(atob(encoded), (character) => character.charCodeAt(0));
+ return new TextDecoder("utf-8").decode(bytes);
+ } catch (error) {
+ console.error("Could not fetch README:", error.message);
+ return "";
+ }
+ }
+
+ async function getLatestRelease(repoInfo) {
+ const endpoint = `https://api.github.com/repos/${repoInfo.organization}/${repoInfo.repository}/releases/latest`;
+
+ try {
+ const response = await fetch(endpoint, ghHeaders());
+ // 404 is the common case
+ return response.ok ? await response.json() : null;
+ } catch (error) {
+ console.error("Could not fetch latest release:", error.message);
+ return null;
+ }
+ }
+
+ const BOILERPLATE_HEADING = /^#{1,4}\s*(license|licence|code of conduct|contributing|security|contributors|acknowledge?ments?|table of contents|changelog|badges|citation)\b/i;
+
+ function stripHtmlCommentsFully(input) {
+ let previous;
+ let current = input;
+ do {
+ previous = current;
+ current = current.replace(//g, "");
+ } while (current !== previous);
+ return current;
+ }
+
+ function condenseReadme(markdown, maxChars) {
+ if (!markdown) {
+ return "";
+ }
+
+ let text = stripHtmlCommentsFully(markdown)
+ .replace(/^(.+)\n={3,}\s*$/gm, "# $1")
+ .replace(/^(.+)\n-{3,}\s*$/gm, "## $1")
+ .replace(/^\s*\[!\[[^\]]*\]\([^)]*\)\]\([^)]*\)\s*$/gm, "")
+ .replace(/!\[[^\]]*\]\(https?:\/\/(img\.shields\.io|badge)[^)]*\)/g, "")
+ .replace(/```[\w-]*\n[\s\S]*?```/g, "[code example]")
+ .replace(/^\s*\|.*\|\s*$/gm, "")
+ .replace(/\n{3,}/g, "\n\n");
+
+ const sections = text
+ .split(/(?=^#{1,4}\s)/m)
+ .filter((section) => !BOILERPLATE_HEADING.test(section));
+
+ text = sections.join("").trim();
+
+ if (text.length <= maxChars) {
+ return text;
+ }
+
+ const head = Math.floor(maxChars * 0.7);
+ const tail = maxChars - head - 20;
+ return `${text.slice(0, head)}\n\n...\n\n${text.slice(-tail)}`;
+ }
+
+ function languagePercentages(languages) {
+ if (!languages) {
+ return "unknown";
+ }
+
+ const entries = Object.entries(languages);
+ const total = entries.reduce((sum, entry) => sum + entry[1], 0);
+
+ if (!total) {
+ return "unknown";
+ }
+
+ return entries
+ .sort((a, b) => b[1] - a[1])
+ .slice(0, 6)
+ .map(([name, bytes]) => `${name} ${Math.round((bytes / total) * 100)}%`)
+ .join(", ");
+ }
+
+ function shortDate(value) {
+ return value ? String(value).slice(0, 10) : "unknown";
+ }
+
+ function buildFactsBlock(context) {
+ const repo = context.repoData;
+ const release = context.latestRelease;
+ const fileNames = context.rootFiles.map((file) => file.name);
+
+ const lines = [
+ `Repository: ${repo.full_name || repo.name}`,
+ `Description: ${repo.description || "(none)"}`,
+ `Topics: ${(repo.topics || []).join(", ") || "(none)"}`,
+ `Languages by bytes: ${languagePercentages(context.languages)}`,
+ `Homepage: ${repo.homepage || "(none)"}`,
+ `Archived: ${repo.archived ? "yes" : "no"} | Fork: ${repo.fork ? "yes" : "no"} | ` +
+ `GitHub Pages: ${repo.has_pages ? "yes" : "no"} | Open issues: ${repo.open_issues_count || 0}`,
+ `Latest release: ${release ? `${release.tag_name} (${shortDate(release.published_at)})` : "(none)"}`,
+ `Last push: ${shortDate(repo.pushed_at)} | Created: ${shortDate(repo.created_at)}`,
+ `Root files: ${fileNames.join(", ") || "(none)"}`
+ ];
+
+ return lines.join("\n");
+ }
+
+ async function gather(repoInfo, prefetched) {
+ const cacheKey = `${repoInfo.organization}/${repoInfo.repository}`;
+
+ if (contextCache.has(cacheKey)) {
+ return contextCache.get(cacheKey);
+ }
+
+ const [readme, latestRelease] = await Promise.all([
+ getReadme(repoInfo),
+ getLatestRelease(repoInfo)
+ ]);
+
+ const context = {
+ repoInfo,
+ repoData: prefetched.repoData,
+ languages: prefetched.languages || {},
+ rootFiles: prefetched.rootFiles || [],
+ readme,
+ latestRelease
+ };
+
+ context.facts = buildFactsBlock(context);
+ contextCache.set(cacheKey, context);
+
+ return context;
+ }
+
+ window.AIContext = {
+ gather,
+ condenseReadme,
+ buildFactsBlock,
+ ghHeaders,
+ getGitHubToken,
+ checkRateLimit
+ };
+})();
diff --git a/js/ai/aiEngine.js b/js/ai/aiEngine.js
new file mode 100644
index 0000000..80d163f
--- /dev/null
+++ b/js/ai/aiEngine.js
@@ -0,0 +1,241 @@
+// WebLLM lifecycle: capability detection, lazy library load, model download
+(function () {
+
+ const LIBRARY_URL = "https://esm.run/@mlc-ai/web-llm@0.2.84";
+ const FALLBACK_LIBRARY_URL = "https://cdn.jsdelivr.net/npm/@mlc-ai/web-llm@0.2.84/+esm";
+ const CACHE_MARKER_KEY = "aiOrchestrator.cachedModel";
+
+ const MODEL = {
+ id: "Llama-3.2-1B-Instruct-q4f16_1-MLC",
+ sizeMB: 879,
+ readmeChars: 6000,
+ proseMaxTokens: 200
+ };
+
+ let library = null;
+ let engine = null;
+ let worker = null;
+ let abortLoad = null;
+ let cancelled = false;
+
+ // WebGPU needs a secure context, so this is false on a LAN IP even in Chrome
+ async function isSupported() {
+ if (!navigator.gpu) {
+ return { ok: false, reason: "no-webgpu" };
+ }
+
+ try {
+ const adapter = await navigator.gpu.requestAdapter();
+ if (!adapter) {
+ return { ok: false, reason: "no-adapter" };
+ }
+ return { ok: true, adapter };
+ } catch (error) {
+ return { ok: false, reason: "no-adapter" };
+ }
+ }
+
+ async function loadLibrary() {
+ if (library) {
+ return library;
+ }
+
+ try {
+ library = await import(LIBRARY_URL);
+ } catch (error) {
+ console.warn("esm.run import failed, trying jsdelivr:", error);
+ library = await import(FALLBACK_LIBRARY_URL);
+ }
+
+ return library;
+ }
+
+ function isModelCached() {
+ try {
+ return localStorage.getItem(CACHE_MARKER_KEY) === MODEL.id;
+ } catch (error) {
+ return false;
+ }
+ }
+
+ function markCached() {
+ try {
+ localStorage.setItem(CACHE_MARKER_KEY, MODEL.id);
+ } catch (error) {
+ }
+ }
+
+ async function clearCache() {
+ const names = await caches.keys();
+
+ await Promise.all(
+ names.filter((name) => name.startsWith("webllm")).map((name) => caches.delete(name))
+ );
+
+ try {
+ localStorage.removeItem(CACHE_MARKER_KEY);
+ } catch (error) {
+ }
+
+ engine = null;
+
+ if (worker) {
+ worker.terminate();
+ worker = null;
+ }
+ }
+
+ async function hasRoomFor() {
+ if (!navigator.storage || !navigator.storage.estimate) {
+ return true;
+ }
+
+ try {
+ const { quota } = await navigator.storage.estimate();
+ if (!quota) {
+ return true;
+ }
+ return quota > MODEL.sizeMB * 1.4 * 1e6;
+ } catch (error) {
+ return true;
+ }
+ }
+
+ function workerURL() {
+ return new URL("js/ai/webLLMWorker.js", document.baseURI);
+ }
+
+ // loads the model, reusing the engine if it is already resident. Racing
+ async function load(onProgress) {
+ cancelled = false;
+
+ if (engine) {
+ return engine;
+ }
+
+ const webllm = await loadLibrary();
+ const initProgressCallback = (report) => onProgress(report);
+ const aborted = new Promise((resolve, reject) => {
+ abortLoad = reject;
+ });
+
+ try {
+ worker = new Worker(workerURL(), { type: "module" });
+ engine = await Promise.race([
+ webllm.CreateWebWorkerMLCEngine(worker, MODEL.id, { initProgressCallback }),
+ aborted
+ ]);
+ } catch (error) {
+ if (cancelled) {
+ throw error;
+ }
+
+ console.warn("Worker engine failed, falling back to the main thread:", error);
+
+ if (worker) {
+ worker.terminate();
+ worker = null;
+ }
+
+ engine = await Promise.race([
+ webllm.CreateMLCEngine(MODEL.id, { initProgressCallback }),
+ aborted
+ ]);
+ }
+
+ abortLoad = null;
+ markCached();
+
+ return engine;
+ }
+
+ function cancel() {
+ cancelled = true;
+
+ if (abortLoad) {
+ abortLoad(new DOMException("Aborted", "AbortError"));
+ abortLoad = null;
+ }
+
+ if (worker) {
+ worker.terminate();
+ worker = null;
+ }
+
+ engine = null;
+ }
+
+ function isCancelled() {
+ return cancelled;
+ }
+
+ const MAX_PROSE_CHARS = 3000;
+
+ async function stopGenerating() {
+ if (typeof engine.interruptGenerate === "function") {
+ try {
+ await engine.interruptGenerate();
+ } catch (error) {
+ // Already stopped
+ }
+ }
+ }
+
+ async function complete(messages, schema, options) {
+ const response = await engine.chat.completions.create({
+ messages,
+ response_format: { type: "json_object", schema: JSON.stringify(schema) },
+ temperature: options.temperature,
+ max_tokens: options.maxTokens
+ });
+
+ const content = response.choices[0].message.content;
+
+ try {
+ return JSON.parse(content);
+ } catch (error) {
+ throw new Error("the model returned incomplete JSON");
+ }
+ }
+
+ async function completeStreamingText(messages, options, onToken) {
+ const stream = await engine.chat.completions.create({
+ messages,
+ stream: true,
+ temperature: options.temperature,
+ max_tokens: options.maxTokens
+ });
+
+ let accumulated = "";
+
+ for await (const chunk of stream) {
+ if (cancelled) {
+ await stopGenerating();
+ return null;
+ }
+
+ accumulated += chunk.choices[0]?.delta?.content || "";
+ onToken(accumulated);
+
+ if (accumulated.length > MAX_PROSE_CHARS) {
+ await stopGenerating();
+ break;
+ }
+ }
+
+ return accumulated;
+ }
+
+ window.AIEngine = {
+ MODEL,
+ isSupported,
+ hasRoomFor,
+ isModelCached,
+ clearCache,
+ load,
+ cancel,
+ isCancelled,
+ complete,
+ completeStreamingText
+ };
+})();
diff --git a/js/ai/aiOrchestrator.js b/js/ai/aiOrchestrator.js
new file mode 100644
index 0000000..474271a
--- /dev/null
+++ b/js/ai/aiOrchestrator.js
@@ -0,0 +1,731 @@
+// orchestrates AI-assisted field suggestions
+(function () {
+ const AI_FIELDS = {
+ prose: ["longDescription"],
+ classify: [
+ "status", "softwareType", "repositoryType", "maintenance", "platforms",
+ "userType", "subsetInHealthcare", "localisation", "userInput", "maturityModelTier"
+ ],
+ categories: ["categories"]
+ };
+
+ const NEVER_TOUCH = new Set([
+ "group", "projects", "systems", "fismaLevel", "contractNumber", "AIUseCaseID",
+ "laborHours", "disclaimerText", "disclaimerURL",
+ "permissions", "organization", "repositoryURL", "repositoryVisibility",
+ "repositoryHost", "vcs", "name", "description", "languages", "tags", "date",
+ "reuseFrequency", "SBOM", "feedbackMechanism"
+ ]);
+
+ const PUBLICCODE_CATEGORIES = [
+ "accounting", "agile-project-management", "applicant-tracking", "application-development",
+ "appointment-scheduling", "backup", "billing-and-invoicing", "blog", "budgeting",
+ "business-intelligence", "business-process-management", "cad", "call-center-management",
+ "cloud-management", "collaboration", "communications", "compliance-management",
+ "contact-management", "content-management", "crm", "customer-service-and-support",
+ "data-analytics", "data-collection", "data-visualization", "design", "design-system",
+ "digital-asset-management", "digital-citizenship", "document-management", "donor-management",
+ "e-commerce", "e-signature", "educational-content", "email-management", "email-marketing",
+ "employee-management", "enterprise-project-management", "enterprise-social-networking",
+ "erp", "event-management", "facility-management", "feedback-and-reviews-management",
+ "financial-reporting", "fleet-management", "fundraising", "gamification",
+ "geographic-information-systems", "grant-management", "graphic-design", "help-desk", "hr",
+ "ide", "identity-management", "instant-messaging", "integrated-library-system",
+ "inventory-management", "it-asset-management", "it-development", "it-management",
+ "it-security", "it-service-management", "knowledge-management", "learning-management-system",
+ "marketing", "mind-mapping", "mobile-marketing", "mobile-payment", "network-management",
+ "office", "online-booking", "online-community", "payment-gateway", "payroll",
+ "predictive-analysis", "procurement", "productivity-suite", "project-collaboration",
+ "project-management", "property-management", "real-estate-management",
+ "regulations-and-directives", "remote-support", "resource-management", "sales-management",
+ "seo", "service-desk", "social-media-management", "survey", "talent-management",
+ "task-management", "taxes-management", "test-management", "time-management",
+ "time-tracking", "translation", "video-conferencing", "video-editing", "visitor-management",
+ "voip", "warehouse-management", "web-collaboration", "web-conferencing", "website-builder",
+ "whistleblowing", "workflow-management", "other"
+ ];
+
+ const SYSTEM_PROMPT =
+ "You are a metadata assistant. You classify a software repository and write short " +
+ "factual descriptions of it for a US government software inventory (code.json). " +
+ "Use ONLY facts present in the CONTEXT. Never invent URLs, people, versions, metrics " +
+ "or agency names. If the context does not support a value, choose the most " +
+ "conservative option. Reply with JSON only, no commentary.";
+
+ const EXTRA_GUIDANCE = [
+ "Extra guidance:",
+ "- status: archived -> \"Archival\"; a release tagged >= 1.0.0 or a live homepage ->",
+ " \"Production\"; only 0.x releases -> \"Beta\"; no releases but pushed in the last 90",
+ " days -> \"Development\"; no releases and no push in 12 months -> \"Ideation\".",
+ "- maturityModelTier: 0 = no README; 1 = README + LICENSE; 2 = also CONTRIBUTING and",
+ " CODE_OF_CONDUCT; 3 = also SECURITY, MAINTAINERS or GOVERNANCE plus CI workflows;",
+ " 4 = also community docs, a roadmap and public meetings. Use the Root files list.",
+ "- subsetInHealthcare: leave the array empty unless the context explicitly mentions",
+ " Medicare, Medicaid, health policy or healthcare operations.",
+ "- localisation: true only if the context mentions translations, i18n or multiple languages."
+ ].join("\n");
+
+ let schema = null;
+ let context = null;
+ let busy = false;
+ let modelAvailable = false;
+ const attempted = new Set();
+ const CLEAR_CACHE_FLASH_MS = 1200;
+
+ // ---- schema derivation -------------------------------------------------
+
+ function currentPage() {
+ const params = new URLSearchParams(window.location.search);
+ return params.get("page") || "gov";
+ }
+
+ function schemaFor(key) {
+ const [head, tail] = key.split(".");
+ const parent = schema.properties[head];
+
+ if (!parent) {
+ return null;
+ }
+
+ return tail ? (parent.properties || {})[tail] || null : parent;
+ }
+
+ function stripToGrammar(field) {
+ if (field.type === "array") {
+ return { type: "array", items: stripToGrammar(field.items), maxItems: 4 };
+ }
+
+ const stripped = { type: Array.isArray(field.type) ? "string" : field.type };
+
+ if (field.enum) {
+ stripped.enum = field.enum;
+ }
+
+ return stripped;
+ }
+
+ function subSchemaFor(keys, extraProperties) {
+ const properties = Object.assign({}, extraProperties);
+
+ for (const key of keys) {
+ if (NEVER_TOUCH.has(key.split(".")[0])) {
+ continue;
+ }
+
+ const field = schemaFor(key);
+ if (!field) {
+ continue;
+ }
+
+ properties[key] = stripToGrammar(field);
+ }
+
+ return {
+ type: "object",
+ properties,
+ required: Object.keys(properties),
+ additionalProperties: false
+ };
+ }
+
+ function fieldGuidance(keys) {
+ return keys
+ .filter((key) => schemaFor(key))
+ .map((key) => {
+ const field = schemaFor(key);
+ const options = field.enum || (field.items && field.items.enum);
+ const choices = options
+ ? `\n choose from: ${options.join(" | ")}`
+ : "\n answer true or false";
+
+ return `- ${key}: ${field.description || ""}${choices}`;
+ })
+ .join("\n");
+ }
+
+ // ---- validation --------------------------------------------------------
+
+ function validateValue(field, value) {
+ const fail = (why) => ({ ok: false, why });
+
+ if (field.enum) {
+ const normalised = field.type === "integer" ? Number(value) : value;
+ return field.enum.includes(normalised)
+ ? { ok: true, value: normalised }
+ : fail(`"${value}" is not one of ${field.enum.join(", ")}`);
+ }
+
+ if (field.type === "array") {
+ if (!Array.isArray(value)) {
+ return fail("expected an array");
+ }
+
+ const allowed = field.items && field.items.enum;
+ const unique = [...new Set(value.map((entry) => String(entry).trim()).filter(Boolean))];
+
+ if (!allowed) {
+ return unique.length ? { ok: true, value: unique.slice(0, 8) } : fail("empty");
+ }
+
+ const kept = unique.filter((entry) => allowed.includes(entry));
+ const dropped = unique.filter((entry) => !allowed.includes(entry));
+
+ return kept.length
+ ? { ok: true, value: kept, dropped }
+ : fail("no valid options returned");
+ }
+
+ if (field.type === "boolean") {
+ if (typeof value === "boolean") {
+ return { ok: true, value };
+ }
+ if (value === "true" || value === "false") {
+ return { ok: true, value: value === "true" };
+ }
+ return fail("expected true or false");
+ }
+
+ if (field.type === "number" || field.type === "integer") {
+ const numeric = Number(value);
+ return Number.isFinite(numeric) ? { ok: true, value: numeric } : fail("not a number");
+ }
+
+ let text = String(value).replace(/\s+/g, " ").trim();
+
+ if (!text) {
+ return fail("empty");
+ }
+ if (field.format === "uri" && !/^https?:\/\//i.test(text)) {
+ return fail("not a URL");
+ }
+ if (field.format === "email" && !/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(text)) {
+ return fail("not an email address");
+ }
+ if (field.maxLength) {
+ text = text.slice(0, field.maxLength);
+ }
+
+ const warn = field.minLength && text.length < field.minLength
+ ? `below the ${field.minLength}-character minimum`
+ : undefined;
+
+ return { ok: true, value: text, warn };
+ }
+
+ // ---- form.io interop ---------------------------------------------------
+
+ function toWidgetValue(field, value) {
+ switch (determineType(field)) {
+ case "selectboxes": {
+ const dictionary = {};
+ for (const option of field.items.enum) {
+ dictionary[option] = false;
+ }
+ for (const entry of value) {
+ if (Object.prototype.hasOwnProperty.call(dictionary, entry)) {
+ dictionary[entry] = true;
+ }
+ }
+ return dictionary;
+ }
+ case "select-boolean":
+ return value === true || value === "true" ? "true" : "false";
+ case "radio":
+ return String(value);
+ case "tags":
+ return Array.isArray(value) ? value : [];
+ case "number":
+ case "integer":
+ return Number(value);
+ default:
+ return value;
+ }
+ }
+
+ function isFieldEmpty(key) {
+ const form = window.formIOInstance;
+ const [head, tail] = key.split(".");
+ const component = form.getComponent(head);
+
+ if (!component) {
+ return false;
+ }
+
+ const current = component.getValue();
+ const value = tail ? (current || {})[tail] : current;
+
+ if (value === null || value === undefined || value === "") {
+ return true;
+ }
+ if (Array.isArray(value)) {
+ return !value.length;
+ }
+ if (typeof value === "object") {
+ return Object.values(value).every((entry) => !entry);
+ }
+
+ return false;
+ }
+
+ function setSchemaValue(key, value) {
+ const form = window.formIOInstance;
+ const [head, tail] = key.split(".");
+ const component = form.getComponent(head);
+
+ if (!component) {
+ throw new Error(`no component "${head}"`);
+ }
+
+ if (!tail) {
+ component.setValue(value);
+ return;
+ }
+
+ const current = component.getValue() || {};
+ current[tail] = value;
+ component.setValue(current);
+ }
+
+ // ---- prompts -----------------------------------------------------------
+
+ function baseMessages() {
+ const readme = window.AIContext.condenseReadme(context.readme, window.AIEngine.MODEL.readmeChars);
+
+ return [
+ { role: "system", content: SYSTEM_PROMPT },
+ {
+ role: "user",
+ content: `CONTEXT\n=======\n${context.facts}\n\nREADME (condensed)\n==================\n${readme}`
+ }
+ ];
+ }
+
+ const PROSE_TASK = [
+ "Write the \"longDescription\" field for this repository's code.json entry.",
+ "",
+ "Requirements:",
+ "- Exactly 2 or 3 sentences, between 150 and 400 characters. Be concise.",
+ "- Plain prose. No markdown, no bullet lists, no repetition.",
+ "- Say what the software does and who would use it. Nothing else.",
+ "- Use only facts from the CONTEXT above. Do not invent features, agencies, URLs,",
+ " people or metrics. Do not mention this prompt.",
+ "- Do not start with \"This repository\" - or the project name.",
+ "- Do not copy headings, titles, underlines or any other formatting from the README.",
+ "- Reply with the description only. No preamble, no heading, no quotation marks."
+ ].join("\n");
+
+ function stripArtifacts(text) {
+ return String(text || "")
+ .replace(/^\s*[^\n]{0,60}\r?\n[=\-]{3,}[^\n]*\r?\n/, "")
+ .replace(/^\s*#{1,6}\s+[^\n]{0,80}\r?\n/, "")
+ .replace(/^\s*(?:long\s*description|description|summary)\s*[:\-]+\s*/i, "")
+ .replace(/^\s*(?:sure|certainly|of course|okay|ok)\b[,!.:]?\s*/i, "")
+ .replace(/^\s*here(?:'s| is)\b[^:\n]{0,80}:\s*/i, "")
+ .replace(/^[\s"'`]+|[\s"'`]+$/g, "")
+ .replace(/[=]{3,}|[-]{3,}/g, " ")
+ .replace(/[*_#`]/g, "")
+ .replace(/\s+/g, " ")
+ .trim();
+ }
+
+ function cleanProse(text) {
+ const cleaned = stripArtifacts(text);
+ const lastSentenceEnd = cleaned.lastIndexOf(".");
+
+ if (lastSentenceEnd > 150 && lastSentenceEnd < cleaned.length - 1) {
+ return cleaned.slice(0, lastSentenceEnd + 1);
+ }
+
+ return cleaned;
+ }
+
+ // ---- generation --------------------------------------------------------
+
+ function eligible(keys) {
+ return keys.filter((key) =>
+ schemaFor(key) && isFieldEmpty(key) && !window.AIReviewPanel.has(key) && !attempted.has(key));
+ }
+
+ async function generateProse(onToken) {
+ const keys = eligible(AI_FIELDS.prose);
+ if (!keys.length) {
+ return;
+ }
+
+ const messages = baseMessages().concat({ role: "user", content: PROSE_TASK });
+ const text = await window.AIEngine.completeStreamingText(
+ messages,
+ { temperature: 0.5, maxTokens: window.AIEngine.MODEL.proseMaxTokens },
+ (accumulated) => onToken(accumulated)
+ );
+
+ keys.forEach((key) => attempted.add(key));
+
+ if (text !== null) {
+ window.AIReviewPanel.record("longDescription", cleanProse(text));
+ }
+ }
+
+ async function generateClassifications() {
+ const keys = eligible(AI_FIELDS.classify);
+ if (!keys.length) {
+ return;
+ }
+
+ const responseSchema = subSchemaFor(keys, {});
+ const task = `Classify this repository. Fields:\n${fieldGuidance(keys)}\n\n${EXTRA_GUIDANCE}`;
+
+ const messages = baseMessages().concat({ role: "user", content: task });
+ const result = await window.AIEngine.complete(messages, responseSchema, {
+ temperature: 0.2,
+ maxTokens: 400
+ });
+
+ keys.forEach((key) => attempted.add(key));
+
+ for (const key of keys) {
+ window.AIReviewPanel.record(key, result[key]);
+ }
+ }
+
+ async function generateCategories() {
+ const keys = eligible(AI_FIELDS.categories);
+ if (!keys.length) {
+ return;
+ }
+
+ const responseSchema = {
+ type: "object",
+ properties: {
+ categories: {
+ type: "array",
+ items: { type: "string", enum: PUBLICCODE_CATEGORIES },
+ maxItems: 3
+ }
+ },
+ required: ["categories"],
+ additionalProperties: false
+ };
+
+ const task = "Choose up to three categories that best describe what this software does.";
+ const messages = baseMessages().concat({ role: "user", content: task });
+ const result = await window.AIEngine.complete(messages, responseSchema, {
+ temperature: 0.2,
+ maxTokens: 128
+ });
+
+ keys.forEach((key) => attempted.add(key));
+
+ window.AIReviewPanel.record("categories", result.categories);
+ }
+
+ // ---- run ---------------------------------------------------------------
+
+ function element(id) {
+ return document.getElementById(id);
+ }
+
+ function show(id, visible) {
+ element(id).style.display = visible ? "" : "none";
+ }
+
+ function formatSize(sizeMB) {
+ return sizeMB >= 1000 ? `${(sizeMB / 1000).toFixed(1)} GB` : `${sizeMB} MB`;
+ }
+
+ function setStatus(text) {
+ element("ai-progress-text").textContent = text;
+ }
+
+ function setProgress(fraction) {
+ element("ai-progress").value = Math.round((fraction || 0) * 100);
+ }
+
+ function draftableFields() {
+ const all = AI_FIELDS.prose.concat(AI_FIELDS.classify, AI_FIELDS.categories);
+ return all.filter((key) => schemaFor(key) && isFieldEmpty(key));
+ }
+
+ function remainingModelFields() {
+ return eligible(draftableFields()).length;
+ }
+
+ function updateRunButton() {
+ const button = element("ai-run");
+
+ if (!modelAvailable) {
+ return;
+ }
+
+ if (busy) {
+ button.disabled = true;
+ return;
+ }
+
+ if (window.AIReviewPanel.isReviewing()) {
+ button.disabled = true;
+ button.textContent = window.AIReviewPanel.hasBeenApplied()
+ ? "Discard the drafts below to draft again"
+ : "Apply or discard the drafts below";
+ return;
+ }
+
+ const draftable = (context && schema) ? draftableFields() : [];
+
+ if (!draftable.length) {
+ button.disabled = true;
+ button.textContent = "Nothing left to draft";
+ return;
+ }
+
+ const remaining = remainingModelFields();
+ const count = remaining || draftable.length;
+ const plural = count === 1 ? "field" : "fields";
+
+ button.disabled = false;
+
+ if (!remaining) {
+ button.textContent = `Draft ${count} ${plural} again`;
+ return;
+ }
+
+ button.textContent = window.AIEngine.isModelCached()
+ ? `Draft ${count} ${plural}`
+ : `Download model and draft ${count} ${plural} (~${formatSize(window.AIEngine.MODEL.sizeMB)})`;
+ }
+
+ function revealPanel() {
+ const panel = element("ai-panel");
+
+ panel.style.display = "";
+ panel.classList.add("ai-reveal");
+ show("ai-enhance", false);
+ panel.scrollIntoView({ behavior: "smooth", block: "center" });
+ }
+
+ async function onRepoContextReady(event) {
+ try {
+ if (!schema) {
+ schema = await retrieveFile(`schemas/${currentPage()}/schema.json`);
+ }
+
+ context = await window.AIContext.gather(event.detail.repoInfo, event.detail);
+
+ window.AIReviewPanel.reset();
+ attempted.clear();
+
+ window.AIReviewPanel.applyRules(window.determinations.suggest(context));
+
+ if (modelAvailable && remainingModelFields()) {
+ if (element("ai-panel").style.display === "none") {
+ show("ai-enhance", true);
+ }
+ updateRunButton();
+ }
+ } catch (error) {
+ console.error("AI context gathering failed:", error);
+ }
+ }
+
+ function describeError(error) {
+ const message = String((error && error.message) || error);
+
+ if (/out of memory|device lost|OOM|createBuffer/i.test(message)) {
+ return "Your GPU ran out of memory. Try the Llama 3.2 1B model, or close other tabs.";
+ }
+ if (/QuotaExceeded/i.test(message)) {
+ return "Your browser ran out of storage for the model. Free up disk space, and note " +
+ "that private/incognito windows cannot cache it.";
+ }
+ if (/huggingface|jsdelivr|esm\.run|raw\.githubusercontent|Failed to fetch|NetworkError/i.test(message)) {
+ return "Could not download the model. This needs access to huggingface.co, " +
+ "raw.githubusercontent.com and cdn.jsdelivr.net - if you are on a managed " +
+ "network, those hosts may need to be allowed.";
+ }
+
+ return `In-browser AI failed: ${message}`;
+ }
+
+ async function runStep(label, failed, work) {
+ try {
+ await work();
+ } catch (error) {
+ if (window.AIEngine.isCancelled() || (error && error.name === "AbortError")) {
+ throw error;
+ }
+ console.error(`AI step failed (${label}):`, error);
+ failed.push(label);
+ }
+ }
+
+ function confirmDownload() {
+ if (window.AIEngine.isModelCached()) {
+ return true;
+ }
+
+ return window.confirm(
+ `This downloads the ${formatSize(window.AIEngine.MODEL.sizeMB)} AI model and runs it in this ` +
+ "tab. It's cached afterward so this only happens once. Continue?"
+ );
+ }
+
+ async function run() {
+ if (!remainingModelFields()) {
+ attempted.clear();
+ }
+
+ if (!(await window.AIEngine.hasRoomFor())) {
+ window.showErrorNotification(
+ "Your browser has less storage available than this model needs. " +
+ "Private/incognito windows cannot cache it - try a normal window."
+ );
+ return;
+ }
+
+ if (!confirmDownload()) {
+ return;
+ }
+
+ busy = true;
+ updateRunButton();
+ show("ai-progress-wrap", true);
+ show("ai-cancel", true);
+ element("ai-stream").textContent = "";
+ setProgress(0);
+ setStatus("Preparing the model...");
+
+ if (typeof gas4 === "function") {
+ gas4("ai_generation_started", {
+ form_name: "code.json form",
+ form_id: "formio",
+ form_destination: window.location.pathname,
+ ai_model: window.AIEngine.MODEL.id
+ });
+ }
+
+ try {
+ await window.AIEngine.load((report) => {
+ setProgress(report.progress);
+ setStatus(report.text || "");
+ });
+
+ if (window.AIEngine.isCancelled()) {
+ return;
+ }
+
+ setProgress(1);
+
+ const failed = [];
+
+ await runStep("the long description", failed, () =>
+ generateProse((partial) => {
+ setStatus("Writing the long description (1 of 3)...");
+ element("ai-stream").textContent = stripArtifacts(partial).slice(-800);
+ }));
+
+ setStatus("Classifying fields (2 of 3)...");
+ await runStep("the classification fields", failed, generateClassifications);
+
+ setStatus("Choosing categories (3 of 3)...");
+ await runStep("the categories", failed, generateCategories);
+
+ if (window.AIEngine.isCancelled()) {
+ return;
+ }
+
+ window.AIReviewPanel.render();
+
+ const drafted = window.AIReviewPanel.count();
+
+ if (failed.length && drafted) {
+ window.showErrorNotification(
+ `Drafted ${drafted} field(s), but could not finish ${failed.join(" or ")}.`
+ );
+ } else if (failed.length) {
+ window.showErrorNotification(`The model could not finish ${failed.join(" or ")}.`);
+ }
+ } catch (error) {
+ if (error && error.name === "AbortError") {
+ setStatus("Cancelled.");
+ } else {
+ console.error("AI generation failed:", error);
+ window.showErrorNotification(describeError(error));
+ }
+ } finally {
+ busy = false;
+ show("ai-cancel", false);
+ show("ai-progress-wrap", false);
+ updateRunButton();
+ }
+ }
+
+ async function init() {
+ document.addEventListener("repo-context-ready", onRepoContextReady);
+
+ const applyButton = element("ai-apply");
+ applyButton.dataset.label = applyButton.textContent.trim();
+
+ const support = await window.AIEngine.isSupported();
+
+ if (!support.ok) {
+ console.info("In-browser AI unavailable:", support.reason);
+ return;
+ }
+
+ modelAvailable = true;
+
+ element("ai-enhance").addEventListener("click", revealPanel);
+
+ applyButton.addEventListener("click", () => {
+ window.AIReviewPanel.apply();
+ updateRunButton();
+ });
+
+ element("ai-discard").addEventListener("click", () => {
+ window.AIReviewPanel.reset();
+ updateRunButton();
+ });
+
+ element("ai-run").addEventListener("click", run);
+
+ element("ai-cancel").addEventListener("click", () => {
+ window.AIEngine.cancel();
+ setStatus("Cancelling...");
+ });
+
+ element("ai-clear-cache").addEventListener("click", async (event) => {
+ if (!window.AIEngine.isModelCached()) {
+ return;
+ }
+
+ if (!window.confirm(
+ "This deletes the cached AI model. You'll need to download it again " +
+ "next time you draft fields. Continue?"
+ )) {
+ return;
+ }
+
+ await window.AIEngine.clearCache();
+ updateRunButton();
+ });
+
+ updateRunButton();
+ }
+
+ document.addEventListener("DOMContentLoaded", init);
+
+ window.AIOrchestrator = {
+ AI_FIELDS,
+ NEVER_TOUCH,
+ PUBLICCODE_CATEGORIES,
+ schemaFor,
+ subSchemaFor,
+ validateValue,
+ toWidgetValue,
+ isFieldEmpty,
+ setSchemaValue,
+ cleanProse,
+ stripArtifacts,
+ run
+ };
+})();
diff --git a/js/ai/aiReviewPanel.js b/js/ai/aiReviewPanel.js
new file mode 100644
index 0000000..1b654ea
--- /dev/null
+++ b/js/ai/aiReviewPanel.js
@@ -0,0 +1,325 @@
+// renders AI suggestions for review and writes accepted values into the form
+(function () {
+ const suggestions = {};
+ let reviewing = false;
+ let hasApplied = false;
+
+ function element(id) {
+ return document.getElementById(id);
+ }
+
+ function show(id, visible) {
+ element(id).style.display = visible ? "" : "none";
+ }
+
+ function escapeHTML(text) {
+ return String(text).replace(/[&<>"]/g, (character) => (
+ { "&": "&", "<": "<", ">": ">", '"': """ }[character]
+ ));
+ }
+
+ const BUTTON_FLASH_MS = 1200;
+
+ function flashButton(label) {
+ const button = element("ai-apply");
+
+ button.textContent = label;
+ button.setAttribute("aria-disabled", "true");
+
+ setTimeout(() => {
+ button.textContent = button.dataset.label;
+ button.removeAttribute("aria-disabled");
+ }, BUTTON_FLASH_MS);
+ }
+
+ function lockReviewPanel(count) {
+ const button = element("ai-apply");
+ const plural = count === 1 ? "field" : "fields";
+
+ button.textContent = `✓ Applied ${count} ${plural}`;
+ button.setAttribute("aria-disabled", "true");
+ button.classList.add("ai-button--applied");
+
+ element("ai-review-list").disabled = true;
+ }
+
+ function reset() {
+ const button = element("ai-apply");
+
+ button.textContent = button.dataset.label;
+ button.removeAttribute("aria-disabled");
+ button.classList.remove("ai-button--applied");
+ element("ai-review-list").disabled = false;
+
+ for (const key of Object.keys(suggestions)) {
+ delete suggestions[key];
+ }
+ reviewing = false;
+ hasApplied = false;
+ show("ai-review", false);
+ }
+
+ function editorFor(key, field, value) {
+ const identifier = `ai-f-${key.replace(/\./g, "-")}`;
+
+ switch (determineType(field)) {
+ case "selectboxes":
+ return `