@ptkl/toolkit 0.7.2 → 0.8.8

package/dist/lib/idlToDts.js

@@ -0,0 +1,242 @@
+/**
+ * IDL → TypeScript module-augmentation generator.
+ *
+ * Mirror of the runtime idlToDts.js used by the Monaco editor, but output
+ * targets a `declare module "@ptkl/sdk"` block so the generated `.d.ts` file
+ * extends the SDK's open interfaces at build time.
+ */
+// ── Primitive type conversion ─────────────────────────────────────────────────
+function idlTypeNodeToTs(node, indent = 0) {
+    if (!node)
+        return 'any';
+    switch (node.type) {
+        case 'string': return 'string';
+        case 'number': return 'number';
+        case 'boolean': return 'boolean';
+        case 'any': return 'any';
+        case 'array':
+            return node.items ? `Array<${idlTypeNodeToTs(node.items, indent)}>` : 'any[]';
+        case 'object':
+            if (node.fields && Object.keys(node.fields).length > 0) {
+                return objectShape(node.fields, indent);
+            }
+            return 'Record<string, any>';
+        case 'relation':
+            // When used as a standalone type (not as a field entry),
+            // a relation is a UUID string.
+            return 'string';
+        default:
+            // NamedRef or unknown — treat as any
+            return 'any';
+    }
+}
+const I = '  '; // indent unit
+function objectShape(fields, indent = 0) {
+    const entries = Object.entries(fields);
+    // Keep short objects (≤3 simple fields) inline
+    if (entries.length <= 3 && entries.every(([, n]) => !n.fields && n.type !== 'object')) {
+        const props = entries.map(([key, node]) => {
+            const opt = node.required === false || node.required === undefined;
+            return `${key}${opt ? '?' : ''}: ${idlTypeNodeToTs(node, indent)}`;
+        });
+        return `{ ${props.join('; ')} }`;
+    }
+    const pad = I.repeat(indent + 1);
+    const closePad = I.repeat(indent);
+    const lines = entries.map(([key, node]) => {
+        const opt = node.required === false || node.required === undefined;
+        return `${pad}${key}${opt ? '?' : ''}: ${idlTypeNodeToTs(node, indent + 1)};`;
+    });
+    return `{\n${lines.join('\n')}\n${closePad}}`;
+}
+// ── Relation expansion ────────────────────────────────────────────────────────
+/**
+ * Expands a field map into TypeScript property lines. Relation fields produce
+ * two entries: the UUID field (`field: string`) and the hydrated reference
+ * (`field_RefObj: T` or `field_RefObj: Array<T>`).
+ */
+function expandFieldLines(fields, pad, indent) {
+    const lines = [];
+    for (const [k, node] of Object.entries(fields)) {
+        const opt = node.required === false || node.required === undefined;
+        if (node.type === 'relation') {
+            // UUID string field
+            lines.push(`${pad}${k}${opt ? '?' : ''}: string;`);
+            // Hydrated _RefObj field
+            const itemTs = node.items ? idlTypeNodeToTs(node.items, indent) : 'any';
+            const refType = node.cardinality === 'many' ? `Array<${itemTs}>` : itemTs;
+            lines.push(`${pad}${k}_RefObj?: ${refType};`);
+        }
+        else {
+            lines.push(`${pad}${k}${opt ? '?' : ''}: ${idlTypeNodeToTs(node, indent)};`);
+        }
+    }
+    return lines;
+}
+/**
+ * Like objectShape but expands relation fields into two properties.
+ */
+function objectShapeWithRelations(fields, indent = 0) {
+    const entries = Object.entries(fields);
+    const hasRelation = entries.some(([, n]) => n.type === 'relation');
+    if (!hasRelation)
+        return objectShape(fields, indent); // fast path
+    const pad = I.repeat(indent + 1);
+    const closePad = I.repeat(indent);
+    const lines = expandFieldLines(fields, pad, indent + 1);
+    return `{\n${lines.join('\n')}\n${closePad}}`;
+}
+// ── Top-level generators ──────────────────────────────────────────────────────
+function buildComponentModels(components, baseIndent) {
+    const entries = [];
+    const d = baseIndent;
+    const pad = I.repeat(d);
+    for (const [ref, comp] of Object.entries(components)) {
+        if (!comp)
+            continue;
+        // Collect all schema names from base + extensions.
+        const schemaNames = new Set();
+        for (const s of Object.keys(comp.schemas ?? {}))
+            schemaNames.add(s);
+        for (const ext of Object.values(comp.extensions ?? {})) {
+            if (!ext)
+                continue;
+            for (const s of Object.keys(ext.schemas ?? {}))
+                schemaNames.add(s);
+        }
+        for (const schema of schemaNames) {
+            const key = schema === 'default' ? ref : `${ref}.${schema}`;
+            const baseFields = comp.schemas?.[schema]?.fields;
+            // Collect extension entries for this schema.
+            const extEntries = [];
+            for (const [extName, ext] of Object.entries(comp.extensions ?? {})) {
+                if (!ext)
+                    continue;
+                const extSchemaFields = ext.schemas?.[schema]?.fields;
+                if (extSchemaFields && Object.keys(extSchemaFields).length > 0) {
+                    extEntries.push([extName, extSchemaFields]);
+                }
+            }
+            const hasBase = baseFields && Object.keys(baseFields).length > 0;
+            const hasExt = extEntries.length > 0;
+            if (!hasBase && !hasExt) {
+                entries.push(`${pad}${JSON.stringify(key)}: Record<string, any>;`);
+                continue;
+            }
+            const propLines = [];
+            if (hasBase) {
+                propLines.push(...expandFieldLines(baseFields, `${pad}${I}`, d + 1));
+            }
+            if (hasExt) {
+                const extInner = [];
+                for (const [extName, extFields] of extEntries) {
+                    extInner.push(`${pad}${I}${I}${extName}: ${objectShapeWithRelations(extFields, d + 2)};`);
+                }
+                propLines.push(`${pad}${I}extensions: {\n${extInner.join('\n')}\n${pad}${I}};`);
+            }
+            entries.push(`${pad}${JSON.stringify(key)}: {\n${propLines.join('\n')}\n${pad}};`);
+        }
+    }
+    if (entries.length === 0)
+        return '';
+    return entries.join('\n');
+}
+function buildComponentFunctions(components, baseIndent) {
+    const entries = [];
+    const d = baseIndent;
+    const pad = I.repeat(d);
+    for (const [ref, comp] of Object.entries(components)) {
+        if (!comp)
+            continue;
+        const allFunctions = [
+            ...(comp.functions ?? []),
+            ...Object.values(comp.extensions ?? {}).flatMap(ext => ext?.functions ?? []),
+        ];
+        if (allFunctions.length === 0)
+            continue;
+        const fnLines = [];
+        for (const fn of allFunctions) {
+            const parts = [];
+            if (fn.input && Object.keys(fn.input).length > 0)
+                parts.push(`input: ${objectShape(fn.input, d + 2)}`);
+            if (fn.output)
+                parts.push(`output: ${idlTypeNodeToTs(fn.output, d + 2)}`);
+            if (parts.length === 0)
+                continue;
+            fnLines.push(`${pad}${I}${JSON.stringify(fn.name)}: { ${parts.join('; ')} };`);
+        }
+        if (fnLines.length > 0)
+            entries.push(`${pad}${JSON.stringify(ref)}: {\n${fnLines.join('\n')}\n${pad}};`);
+    }
+    if (entries.length === 0)
+        return '';
+    return entries.join('\n');
+}
+function buildPlatformFunctions(functions, baseIndent) {
+    const entries = [];
+    const d = baseIndent;
+    const pad = I.repeat(d);
+    for (const [name, sig] of Object.entries(functions)) {
+        if (!sig)
+            continue;
+        const parts = [];
+        if (sig.input && Object.keys(sig.input).length > 0)
+            parts.push(`input: ${objectShape(sig.input, d + 1)}`);
+        if (sig.output)
+            parts.push(`output: ${idlTypeNodeToTs(sig.output, d + 1)}`);
+        if (parts.length === 0)
+            continue;
+        entries.push(`${pad}${JSON.stringify(name)}: { ${parts.join('; ')} };`);
+    }
+    if (entries.length === 0)
+        return '';
+    return entries.join('\n');
+}
+// ── Main export ───────────────────────────────────────────────────────────────
+/**
+ * Converts an IDL response into a `declare module "@ptkl/sdk"` augmentation
+ * block. Write the output to a `.d.ts` file and include it in your project
+ * (e.g., via `tsconfig.json` `"include"` or a triple-slash reference).
+ */
+export function idlToModuleAugmentation(idl) {
+    const hasComponents = idl.components && Object.keys(idl.components).length > 0;
+    const hasFunctions = idl.functions && Object.keys(idl.functions).length > 0;
+    if (!hasComponents && !hasFunctions) {
+        return `// No IDL definitions found — nothing to generate.\n`;
+    }
+    const date = new Date().toISOString().slice(0, 10);
+    const lines = [
+        `// Generated by ptkl generate-types on ${date}`,
+        `// Do not edit manually — re-run \`ptkl generate-types\` to refresh.`,
+        ``,
+        `import "@ptkl/sdk";`,
+        `import "@ptkl/sdk/beta";`,
+    ];
+    // Declare interfaces once globally, then extend into both modules.
+    const ifaceNames = [];
+    if (hasComponents) {
+        const models = buildComponentModels(idl.components, 1);
+        if (models) {
+            lines.push(``, `interface _CM {\n${models}\n}`);
+            ifaceNames.push('ComponentModels extends _CM');
+        }
+        const fns = buildComponentFunctions(idl.components, 1);
+        if (fns) {
+            lines.push(``, `interface _CF {\n${fns}\n}`);
+            ifaceNames.push('ComponentFunctions extends _CF');
+        }
+    }
+    if (hasFunctions) {
+        const platFns = buildPlatformFunctions(idl.functions, 1);
+        if (platFns) {
+            lines.push(``, `interface _PF {\n${platFns}\n}`);
+            ifaceNames.push('PlatformFunctions extends _PF');
+        }
+    }
+    if (ifaceNames.length > 0) {
+        const augBody = ifaceNames.map(n => `  interface ${n} {}`).join('\n');
+        lines.push(``, `declare module "@ptkl/sdk" {\n${augBody}\n}`, ``, `declare module "@ptkl/sdk/beta" {\n${augBody}\n}`);
+    }
+    lines.push(``);
+    return lines.join('\n');
+}

package/dist/lib/util.js

@@ -1,5 +1,5 @@
 import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import Api from '@ptkl/sdk';
+import { Platform } from '@ptkl/sdk';
 export default class Util {
     static profilePath = `${process.env.HOME}/.ptkl`;
     static fileName = "profiles.json";
@@ -69,6 +69,6 @@ export default class Util {
     }
     static getClientForProfile() {
         const profile = Util.getCurrentProfile();
-        return new Api({ project: profile.project, token: profile.token, host: profile.host });
+        return new Platform({ project: profile.project, token: profile.token, host: profile.host });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ptkl/toolkit",
-  "version": "0.7.2",
+  "version": "0.8.8",
   "description": "A command-line toolkit for managing Protokol platform applications, profiles, functions, and components",
   "keywords": [
     "protokol",
@@ -28,9 +28,17 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-proposal-decorators": "^7.28.0",
+    "@babel/plugin-transform-class-static-block": "^7.28.3",
+    "@babel/preset-react": "^7.28.5",
+    "@babel/preset-typescript": "^7.28.5",
     "@babel/standalone": "^7.26.10",
     "@inquirer/password": "^4.0.21",
-    "@ptkl/sdk": "^0.9.12",
+    "@ptkl/sdk": "^1.5.1",
+    "@rollup/plugin-babel": "^6.1.0",
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
     "@types/axios": "^0.14.0",
     "@types/commander": "^2.12.2",
     "@types/js-yaml": "^4.0.9",
@@ -45,6 +53,7 @@
     "lodash": "^4.17.21",
     "open": "^10.1.2",
     "rollup": "^4.34.6",
+    "sass": "^1.95.1",
     "tar": "^7.4.3",
     "vite": "^6.0.6",
     "vue-template-compiler": "^2.7.16",