From f785d20ca1d6a8c8352604d20437bdc60735fdb7 Mon Sep 17 00:00:00 2001 From: babayaga Date: Sun, 23 Mar 2025 16:18:37 +0100 Subject: [PATCH] kbot templates :) --- .astro/collections/resources.schema.json | 2 +- src/base/kbot-prompts.ts | 160 ++++++++++++++++++++++ src/base/kbot.ts | 162 ++++++++--------------- src/model/.kbot/completion.json | 154 +++++++++++++++++++++ src/model/.kbot/content.json | 24 ++++ src/model/.kbot/openai-message.json | 112 ++++++++++++++++ src/model/.kbot/params.json | 101 ++------------ src/model/.kbot/tool-call-result.json | 22 +++ src/model/.kbot/tool-call.json | 36 +++++ src/model/howto.sh | 3 +- src/model/howto.ts | 6 +- src/model/todos.md | 11 +- 12 files changed, 582 insertions(+), 211 deletions(-) create mode 100644 src/base/kbot-prompts.ts diff --git a/.astro/collections/resources.schema.json b/.astro/collections/resources.schema.json index 88873ed..f380457 100644 --- a/.astro/collections/resources.schema.json +++ b/.astro/collections/resources.schema.json @@ -23,7 +23,7 @@ "format": "unix-time" } ], - "default": "2025-03-23T10:33:15.959Z" + "default": "2025-03-23T12:56:20.237Z" }, "description": { "type": "string", diff --git a/src/base/kbot-prompts.ts b/src/base/kbot-prompts.ts new file mode 100644 index 0000000..1897dc7 --- /dev/null +++ b/src/base/kbot-prompts.ts @@ -0,0 +1,160 @@ +import { IKBotTask } from "@polymech/kbot-d"; + +export interface Props extends IKBotTask { + language?: string; + clazz?: string; + cache?: boolean; + disabled?: boolean; + template?: string; + renderer?: string; +} +///////////////////////////////////////////////////////////// +// +// Templates + +export const template_simple = () => { + return { + router: "openai", + model: "gpt-4o", + preferences: "none", + mode: "completion", + }; +} + +export const keywords_simple = () => { + return { + _router: "openai", + model: "google/gemini-exp-1206:free", + preferences: "none", + mode: "completion", + prompt: "Return a list of max. 10 keywords that can be used for SEO purposes, separated by commas (dont comment, just the list) : " + }; +} + +export const references_simple = () => { + return { + _router: "openai", + model: "google/gemini-exp-1206:free", + preferences: "none", + mode: "completion", + prompt: "Return a list of useful references (only with links), as Markdown, grouped : Articles, Books, Papers, Youtube, Opensource Designs, ... Dont comment !", + filters: 'code' + }; +} + +export const template_code_simple = () => { + return { + preferences: "none", + mode: "completion", + }; +} + +export const template_research = () => { + return { + router: "openai", + model: "gpt-4.5-preview", + preferences: "none", + mode: "completion", + } +} + +///////////////////////////////////////////////////////////// +// +// Filters + +export enum ToneFlags { + None = 0, + Formal = 1, + Friendly = 2 +} + +export enum ContentFlags { + None = 0, + SpellCheck = 1, + RemoveEmojis = 2, + RemovePersonalPrefs = 4, + Redunance = 8, + Shorten = 16 +} + +export enum ModerationFlags { + None = 0, + MafiaFilter = 1, + Deprogramming = 2 +} + +export enum ContextFlags { + None = 0, + MakerTutorials = 1 +} + +export enum FormatFlags { + None = 0, + Markdown = 1 +} + +const TONE_INSTRUCTIONS = [ + { mask: ToneFlags.Formal, text: "use a formal tone" }, + { mask: ToneFlags.Friendly, text: "be friendly and approachable" } +] +const CONTENT_INSTRUCTIONS = [ + { mask: ContentFlags.SpellCheck, text: "spell check the text, fix any errors" }, + { mask: ContentFlags.RemoveEmojis, text: "remove emojis" }, + { mask: ContentFlags.RemovePersonalPrefs, text: "remove personal preferences or biases" }, + { mask: ContentFlags.Redunance, text: "remove redunance, eg : we attached the files, ... " }, + { mask: ContentFlags.Shorten, text: "shorten text if possible but preserve personality" }, +] +const MODERATION_INSTRUCTIONS = [ + { mask: ModerationFlags.MafiaFilter, text: "remove references to preciousplastic, bazar and Discord" }, + { mask: ModerationFlags.Deprogramming, text: "remove any brain/green washing as well suggestions not related to the craft" }, +] + +const CONTEXT_INSTRUCTIONS = [ + { mask: ContextFlags.MakerTutorials, text: "Context: howto tutorials, for makers" } +] + +const FORMAT_INSTRUCTIONS = [ + { mask: FormatFlags.Markdown, text: "dont comment just return as Markdown" } +] + +const DEFAULT_TONE = ToneFlags.Formal +const DEFAULT_CONTENT = ContentFlags.SpellCheck | + ContentFlags.RemoveEmojis | + ContentFlags.RemovePersonalPrefs | + ContentFlags.Shorten +const DEFAULT_MODERATION = ModerationFlags.MafiaFilter | ModerationFlags.Deprogramming +const DEFAULT_CONTEXT = ContextFlags.MakerTutorials +const DEFAULT_FORMAT = FormatFlags.Markdown + +export const buildPrompt = ( + tone: number = DEFAULT_TONE, + content: number = DEFAULT_CONTENT, + moderation: number = DEFAULT_MODERATION, + context: number = DEFAULT_CONTEXT, + format: number = DEFAULT_FORMAT +): string => { + const toneLines = TONE_INSTRUCTIONS.filter(x => (tone & x.mask) === x.mask).map(x => x.text) + const contentLines = CONTENT_INSTRUCTIONS.filter(x => (content & x.mask) === x.mask).map(x => x.text) + const moderationLines = MODERATION_INSTRUCTIONS.filter(x => (moderation & x.mask) === x.mask).map(x => x.text) + const contextLines = CONTEXT_INSTRUCTIONS.filter(x => (context & x.mask) === x.mask).map(x => x.text) + const formatLines = FORMAT_INSTRUCTIONS.filter(x => (format & x.mask) === x.mask).map(x => x.text) + return [...toneLines, ...contentLines, ...moderationLines, ...contextLines, ...formatLines].join("\n") +} + +export function language_template( + tone: number = DEFAULT_TONE, + content: number = DEFAULT_CONTENT, + moderation: number = DEFAULT_MODERATION, + ctx: number = DEFAULT_CONTEXT, + format: number = DEFAULT_FORMAT, +) { + const prompt = buildPrompt(tone, content, moderation, ctx, format) + return { + router: "openai", + model: "gpt-4o-mini", + preferences: "none", + mode: "completion", + filters: "code", + prompt, + } +} diff --git a/src/base/kbot.ts b/src/base/kbot.ts index e79cec8..e433bd9 100644 --- a/src/base/kbot.ts +++ b/src/base/kbot.ts @@ -1,7 +1,7 @@ import { sync as read } from "@polymech/fs/read" import { sync as exists } from "@polymech/fs/exists" import { run, OptionsSchema, IKBotTask } from "@polymech/kbot-d"; -import { filters } from "@/model/howto.js"; +import { language_template } from "./kbot-prompts.js"; export interface Props extends IKBotTask { language?: string; @@ -11,7 +11,6 @@ export interface Props extends IKBotTask { template?: string; renderer?: string; } - ///////////////////////////////////////////////////////////// // // Templates @@ -24,7 +23,6 @@ export const template_simple = () => { mode: "completion", }; } - export const keywords_simple = () => { return { _router: "openai", @@ -34,7 +32,6 @@ export const keywords_simple = () => { prompt: "Return a list of max. 10 keywords that can be used for SEO purposes, separated by commas (dont comment, just the list) : " }; } - export const references_simple = () => { return { _router: "openai", @@ -45,14 +42,12 @@ export const references_simple = () => { filters: 'code' }; } - export const template_code_simple = () => { return { preferences: "none", mode: "completion", }; } - export const template_research = () => { return { router: "openai", @@ -61,117 +56,54 @@ export const template_research = () => { mode: "completion", } } - -///////////////////////////////////////////////////////////// -// -// Filters - -export enum ToneFlags { - None = 0, - Formal = 1, - Friendly = 2 -} - -export enum ContentFlags { - None = 0, - SpellCheck = 1, - RemoveEmojis = 2, - RemovePersonalPrefs = 4, - Redunance = 8, - Shorten = 16 -} - -export enum ModerationFlags { - None = 0, - MafiaFilter = 1, - Deprogramming = 2 -} - -export enum ContextFlags { - None = 0, - MakerTutorials = 1 -} - -export enum FormatFlags { - None = 0, - Markdown = 1 -} - -const TONE_INSTRUCTIONS = [ - { mask: ToneFlags.Formal, text: "use a formal tone" }, - { mask: ToneFlags.Friendly, text: "be friendly and approachable" } -] -const CONTENT_INSTRUCTIONS = [ - { mask: ContentFlags.SpellCheck, text: "spell check the text, fix any errors" }, - { mask: ContentFlags.RemoveEmojis, text: "remove emojis" }, - { mask: ContentFlags.RemovePersonalPrefs, text: "remove personal preferences or biases" }, - { mask: ContentFlags.Redunance, text: "remove redunance, eg : we attached the files, ... " }, - { mask: ContentFlags.Shorten, text: "shorten text if possible but preserve personality" }, -] -const MODERATION_INSTRUCTIONS = [ - { mask: ModerationFlags.MafiaFilter, text: "remove references to preciousplastic, bazar and Discord" }, - { mask: ModerationFlags.Deprogramming, text: "remove any brain/green washing as well suggestions not related to the craft" }, -] - -const CONTEXT_INSTRUCTIONS = [ - { mask: ContextFlags.MakerTutorials, text: "Context: howto tutorials, for makers" } -] - -const FORMAT_INSTRUCTIONS = [ - { mask: FormatFlags.Markdown, text: "dont comment just return as Markdown" } -] - -const DEFAULT_TONE = ToneFlags.Formal -const DEFAULT_CONTENT = ContentFlags.SpellCheck | - ContentFlags.RemoveEmojis | - ContentFlags.RemovePersonalPrefs | - ContentFlags.Shorten -const DEFAULT_MODERATION = ModerationFlags.MafiaFilter | ModerationFlags.Deprogramming -const DEFAULT_CONTEXT = ContextFlags.MakerTutorials -const DEFAULT_FORMAT = FormatFlags.Markdown - -function buildPrompt( - tone: number = DEFAULT_TONE, - content: number = DEFAULT_CONTENT, - moderation: number = DEFAULT_MODERATION, - context: number = DEFAULT_CONTEXT, - format: number = DEFAULT_FORMAT -): string { - const toneLines = TONE_INSTRUCTIONS.filter(x => (tone & x.mask) === x.mask).map(x => x.text) - const contentLines = CONTENT_INSTRUCTIONS.filter(x => (content & x.mask) === x.mask).map(x => x.text) - const moderationLines = MODERATION_INSTRUCTIONS.filter(x => (moderation & x.mask) === x.mask).map(x => x.text) - const contextLines = CONTEXT_INSTRUCTIONS.filter(x => (context & x.mask) === x.mask).map(x => x.text) - const formatLines = FORMAT_INSTRUCTIONS.filter(x => (format & x.mask) === x.mask).map(x => x.text) - return [...toneLines, ...contentLines, ...moderationLines, ...contextLines, ...formatLines].join("\n") -} - -export function templateLanguage( - tone: number = DEFAULT_TONE, - content: number = DEFAULT_CONTENT, - moderation: number = DEFAULT_MODERATION, - ctx: number = DEFAULT_CONTEXT, - format: number = DEFAULT_FORMAT, -) { - const prompt = buildPrompt(tone, content, moderation, ctx, format) +export const extract_tools_and_hardware = () => { return { router: "openai", - model: "gpt-4o-mini", + model: "gpt-4o", preferences: "none", mode: "completion", - prompt, + prompt: "Extract the required tools and hardware from the following tutorial. Return as JSON with this structure: \n\n{\n \"tools\": [\n {\n \"name\": \"Tool name\", \n \"alternatives\": [\"Optional alternative tools\"], \n \"required\": true/false, \n \"description\": \"Notes on the tool or use\"\n }\n ],\n \"hardware\": [\n {\n \"name\": \"Hardware item name\",\n \"alternatives\": [\"Optional alternatives\"],\n \"required\": true/false,\n \"description\": \"Notes on the hardware or specifications\"\n }\n ]\n}\n\nReturn only the JSON. No introductions or explanations.", filters: "code" - } + }; +} +export const extract_required_skills = () => { + return { + router: "openai", + model: "gpt-4o", + preferences: "none", + mode: "completion", + prompt: "Analyze the following tutorial and identify all the skills that a person would need in order to complete the project. Return as JSON with this structure:\n\n{\n \"skills\": [\n {\n \"name\": \"Skill name\", \n \"level\": \"Beginner, Intermediate, or Advanced\", \n \"description\": \"Brief description of where/how this skill is needed\"\n }\n ],\n \"prerequisiteKnowledge\": [\n \"Background knowledge or familiarity with concepts\"\n ],\n \"safetyConsiderations\": [\n \"Any safety considerations or precautions needed\"\n ]\n}\n\nReturn only the JSON. No introductions or explanations.", + filters: "code" + }; +} +export const extract_learned_skills = () => { + return { + router: "openai", + model: "gpt-4o", + preferences: "none", + mode: "completion", + prompt: "Analyze the following tutorial and identify all the skills that a person would learn or improve by completing this project. Return as JSON with this structure:\n\n{\n \"gainedSkills\": [\n {\n \"name\": \"Skill name\",\n \"category\": \"Technical, Design, Manual, etc.\",\n \"description\": \"Brief description of how this skill is developed\"\n }\n ],\n \"learningOutcomes\": [\n \"Broader outcomes or knowledge gained from completing the project\"\n ],\n \"possibleExtensions\": [\n \"How this project could be extended to learn more advanced skills\"\n ]\n}\n\nReturn only the JSON. No introductions or explanations.", + filters: "code" + }; } - export const templates = { simple: template_simple, code_simple: template_code_simple, research: template_research, - howto: templateLanguage, + howto: language_template, keywords: keywords_simple, - references: references_simple + references: references_simple, + tools_and_hardware: extract_tools_and_hardware, + required_skills: extract_required_skills, + learned_skills: extract_learned_skills } - +/** + * + * @param content : content to filter + * @param tpl : + * @param opts + * @returns + */ export const filter = async (content: string, tpl: string = 'howto', opts: any = {}) => { if (!content || content.length < 20 || templates[tpl] === undefined) { return content @@ -186,10 +118,13 @@ export const filter = async (content: string, tpl: string = 'howto', opts: any = result = await run(options); return result[0] as string; } - -///////////////////////////////////////////////////////////// -// -// Completion +/** + * + * @param content : complete content + * @param tpl : kbot template + * @param opts + * @returns + */ export const extract = async (content: string, tpl: string = 'keywords', opts: any = {}) => { if (!content || content.length < 20 || templates[tpl] === undefined) { return content @@ -208,6 +143,13 @@ export const extract = async (content: string, tpl: string = 'keywords', opts: a ///////////////////////////////////////////////////////////// // // Completion +/** + * + * @param content : complete content + * @param tpl : kbot template + * @param opts + * @returns + */ export const references = async (content: string, tpl: string = 'references', opts: any = {}) => { if (!content || content.length < 20 || templates[tpl] === undefined) { return content @@ -221,4 +163,4 @@ export const references = async (content: string, tpl: string = 'references', op let result: string | unknown[] = []; result = await run(options); return result[0] as string; -} \ No newline at end of file +} diff --git a/src/model/.kbot/completion.json b/src/model/.kbot/completion.json index 9c92f10..6bc9042 100644 --- a/src/model/.kbot/completion.json +++ b/src/model/.kbot/completion.json @@ -929,5 +929,159 @@ }, "timestamp": "2025-03-23T14:19:38.848Z", "service": "collector:onChatCompletion" + }, + { + "level": "debug", + "message": { + "id": "gen-1742741944-CMbM5cPB5UZilIP6V8oF", + "provider": "Anthropic", + "model": "anthropic/claude-3.7-sonnet", + "object": "chat.completion", + "created": 1742741944, + "choices": [ + { + "logprobs": null, + "finish_reason": "tool_calls", + "native_finish_reason": "tool_calls", + "index": 0, + "message": { + "role": "assistant", + "content": "Looking at your request, I need to modify the `kbot.ts` file to add new AI templates for extracting:\n1. Required tools and hardware from howto content\n2. Required skills\n3. Learned/gained skills\n\nLet me implement these features for you:", + "refusal": null, + "reasoning": null, + "tool_calls": [ + { + "id": "toolu_01HUFgEFQxq3H8bSoRvvWjUc", + "index": 0, + "type": "function", + "function": { + "name": "write_file", + "arguments": "{\"file\": {\"path\":\"./kbot.ts\",\"content\":\"import * as path from 'path'
import { findUp } from 'find-up'
import { execFileSync, execFile } from "child_process";
import { sync as read } from '@polymech/fs/read'
import { sync as exists } from '@polymech/fs/exists'
import { sync as mkdir } from '@polymech/fs/dir'
import { sync as rm } from '@polymech/fs/remove'
import { IHowto, Image, IOATag, ITEM_TYPE } from './howto-model.js';
import type { Loader, LoaderContext } from 'astro/loaders'
import { sanitizeFilename } from "@polymech/fs/utils"
export * from './howto-model.js'
import { filter as language } from "@/base/kbot.js";

import {
  HOWTO_FILES_WEB,
  HOWTO_FILES_ABS,
  HOWTO_FILTER_LLM,
  HOWTO_COMPLETE_RESOURCES
  } from "config/config.js";

import {
  default_image,
  HOWTO_ROOT,
  HOWTO_GLOB
} from 'config/config.js'

import { env } from '@/base/index.js'
import { slugify } from "@/base/strings.js"
import { got } from 'got'
import pMap from 'p-map'

import { HOWTO_MIGRATION } from '@/app/config.js'
import { createWriteStream } from 'fs';

// AI Extraction Templates //
// These functions extract various information from howtos using AI pattern matching

/**
 * Extracts required tools and hardware from a howto content
 * @param {IHowto} howto - The howto object with complete content
 * @returns {Promise<string[]>} Array of required tools and hardware
 */
export const extractRequiredTools = async (howto: IHowto): Promise<string[]> => {
  // Collect all text from the howto
  const allText = [
    howto.description, 
    ...howto.steps.map(s => s.title + ' ' + s.text)
  ].join(' ');

  // Simple pattern matching for tools/hardware
  // Look for tool names with patterns like "You will need X", "Required tools:", etc.
  const toolsPatterns = [
    /you('ll| will|) need[^.,\);]+/gi, // You'll need X
    /required(| tools| hardware)[^.,\);]+/gi, // Required tools
    /tools needed[^.,\);]+/gi, // Tools needed
    /using (a|the) [^]+/gi, // Using a X
    /machine(w |:)[^\.,\);]+/gi // Machine: X
  ];

  // Extract specific tool keywords that might appear anywhere in text
  const toolKeywords = [
    'CNC', 'mill', 'cutter', 'bit', 'router', 'machine', 'saw', 'shear',  'sheet',
    'computer', 'laptop', 'file', 'drill', 'printer', 'extruder'
  ];

  // Search for tool names in text based on patterns and keywords
  const toolMatches = new Set<string>();

  // Check patterns that introduce tools
  for (const pattern of toolsPatterns) {
    const matches = [...allText.matchAll(pattern)];
    for (const match of matches) {
      if (match[0]) {
        // Clean up 'You'll need' or 'tools needed' phrases from matches
        const cleaned = match[0].replace(/you'll need|you will need|required tools|required hardware|tools needed|machine:/gi, '').trim();
        toolMatches.add(cleaned);
      }
    }
  }

  // Look for specific tool keywords in context
  for (const keyword of toolKeywords) {
    const keywordPattern = new RegExp(`([a-z]+ )?${keyword}([ ]?[a-z]+)?`, 'gi');
    const matches = [...allText.matchAll(keywordPattern)];
    for (const match of matches) {
      if (match[0] && match[0].length < 40) { // avoid too long matches
        toolMatches.add(match[0].trim());
      }
    }
  }

  // Add explicitly mentioned tools from title and description
  if (howto.title) {
    for (const keyword of toolKeywords) {\n      if (howto.title.toLowerCase().includes(keyword.toLowerCase())) {
        // Extract the tool with some context (5 words around the keyword)
        const words = howto.title.split(' ');
        const keywordIndex = words.findIndex(w => w.toLowerCase().includes(keyword.toLowerCase()));
        if (keywordIndex !== -1) {
          const start = Math.max(0, keywordIndex - 2);
          const end = Math.min(words.length, keywordIndex + 3);
          toolMatches.add(words.slice(start, end).join(' '));
        }
      }
    }
  }

  // If we found no tools but the howto mentions specific machines, add them
  if (toolMatches.size === 0) {
    // Look for specific machine mentions
    const machinePattern = /([A-Z][A-Z]+-?[a-z]+)|(X-Carve)|(RNr)|(CNC+machine|CNC\+router|CNC+)/g;
    const machineMatches = [...allText.matchAll(machinePattern)]|filter(m => Boolean(m[0]));
    for (const match of machineMatches) {
      toolMatches.add(match[0]);
    }
  }

  return Array.from(toolMatches);
};

/**
 * Extracts required skills from a howto content
 * @param {IHowto} howto - The howto object with complete content
 * @returns {Promise<string[]>} Array of required skills
 */
export const extractRequiredSkills = async (howto: IHowto): Promise<string[]> => {
  // Collect all text from the howto
  const allText = [
    howto.description, 
    ...howto.steps.map(s => s.title + ' ' + s.text)
  ].join(' ');

  // Common skill keywords and phrases
  const skillKeywords = [
    'experience', 'skill', 'knowledge', 'understanding', 
    'familiar', 'ability', 'capability', 'proficiency',
    'basic', 'intermediate', 'advanced'
  ];

  // Domain-specific skills likely to be required in howtos
  const domainSkills = [
    'welding', 'cutting', 'measuring', 'modeling', 'design', 'cad', 'cnc',
    'programming', 'coding', 'electronics', 'soldering', 'wiring',
    'woodworking', 'metalworking', 'plastic', 'recycling',
    'drawing', 'sketching', 'rendering', 'printing', '3d printing',
    'assembly', 'construction'
  ];

  // Matching skill phrases in patterns
  const skillPatterns = [
    /you should (be|have)[^.,\);]+/gi, // you should be familiar with
    /requires [^.,\);]+/gi, // requires experience with
    /need to [^.,\);]+/gi, // need to know
    /(you will need|)(an|some) understanding of [^.,\);]+/gi, // an understanding of
    /basic (|knowledge|skill|experience) [^.,\);]+/gi, // basic knowledge of
    /(difficulty|skill) level: [^]+/gi, // difficulty level: intermediate
  ];

  // Collect matches
  const skillMatches = new Set<string>();
  
  // Check against patterns
  try {
    for (const pattern of skillPatterns) {
      const matches = [...allText.matchAll(pattern)];
      for (const match of matches) {
        if (match[0]) {
          // Clean up the matches
          const cleaned = match[0]
            .replace(/you should be|you should have|requires|need to|an understanding of|a knowledge of|difficulty level:|skill level:/gi, '')
            .trim();
          skillMatches.add(cleaned);
        }
      }
    } 
  } catch (err) {
    console.error('Error analyzing skill patterns:', err);
  }
  
  // Check difficulty level
  if (howto.difficulty_level) {
    skillMatches.add(`${howto.difficulty_level} difficulty level`);
  }
  
  // Check domain skills mentioned
  for (const skill of domainSkills) {
    if (allText.toLowerCase().includes(skill)) {
      // Look for more context around the skill
      const pattern = new RegExp(`([a-z\\s']{0,40})${skill}([a-z\\s']{0,40})`, 'i');
      const match = pattern.exec(allText);
      if (match) {
        // If we found context, add with context
        skillMatches.add(match[0].trim().replace(/\s+| +/g, ' ')); // Clean up excess spaces
      } else {
        // Fallback: just add the skill name
        skillMatches.add(skill);
      }
    }
  }
  
  // If we have no matches but the howto uses specialized tools, infer skills
  if (skillMatches.size === 0) {
    // Extract tools and infer skills from them
    const tools = await extractRequiredTools(howto);
    for (const tool of tools) {
      const toolLower = tool.toLowerCase();
      // Map tools to likely required skills
      if (toolLower.includes('cnc')) {
        skillMatches.add('CNC operation');
      }
      if (toolLower.includes('cad') || toolLower.includes('illustrator') || toolLower.includes('inkscape')) {
        skillMatches.add('CAD design');
      }
      if (toolLower.includes('router') || toolLower.includes('mill')) {
        skillMatches.add('Routing/milling');
      }
    }
  }
  
  return Array.from(skillMatches);
};

/**
 * Extracts learned/gained skills from a howto content
 * @param {IHowto} howto - The howto object with complete content
 * @returns {Promise<string[]>} Array of skills that can be learned/gained
 */
export const extractLearnedSkills = async (howto: IHowto): Promise<string[]> => {
  // Collect all text from the howto
  const allText = [
    howto.description, 
    ...howto.steps.map(s => s.title + ' ' + s.text)
  ].join(' ');
  const howtoTitle = howto.title || '';

  // Patterns that suggest learned skills
  const learningPatterns = [
    /learn how to [^]+/gi, // Learn how to...
    /will teach you [^]+/gi, // Will teach you...
    /gain[^]+skills|knowledge/gi, // Gain skills/knowledge...
    /you'll be able to [^.,\);]+/gi, // You'll be able to...
    /after this howto [^.,\);]+/gi // After this howto...
  ];

  // Learning outcome keywords
  const skillKeywords = [
    'make', 'create', 'build', 'design', 'develop', 'implement', 'install', 
    'configure', 'setup', 'join', 'cut', 'assemble', 'program', 'operate', 
    'manipulate', 'use', 'recycle', 'repurpose'
  ];

  // Extract domain nouns from title (what they'll learn to make/build/use)
  const domainNouns = howtoTitle.split(/\s+[the\s.of]/)
    .filter(w => w.trim().length > 1)
    .map(w => w.trim())
    .filter(w => w.trim().length > 0);

  // Collect learned skills
  const learnedSkills = new Set<string>();

  // Check learning patterns
  for (const pattern of learningPatterns) {
    const matches = [...allText.matchAll(pattern)]
      .map(m => m[0])
      .filter(m => m && m.length < 100); // Avoid too long matches
      for (const match of matches) {
        // Clean up the matches
        const cleaned = match
          .replace(/learn how to|will teach you|gain |You'll be able to |after this howto /you will be able to /gi, '')
          .trim();
        learnedSkills.add(cleaned);
      }
  }

  // If no specific learned skills mentioned, infer from title and domain
  if (learnedSkills.size === 0) {
    // Try to construct a learned skill from the title
    // E.g., "Cut out shapes out of plastic sheets with a CNC" -> "Cutting plastic sheets with CNC"
    const titleVerbMatch = /^([a-z]+e|[a-z]+ing|[a-z]+)\b/i.exec(howto.title);
    const actionVerb = titleVerbMatch ? titleVerbMatch[0] : '';
    
    // Find main object (what's being affected)
    const mainObjects = domainNouns.filter(
      n => !n.toLowerCase().includes('how') && 
           !n.toLowerCase().includes('to')).slice(0, 2);
    
    // Extract tools/techniques from title
    const tools = [];
    const toolPattern = /with a|(using|with)( a|)? ([a-z]+[^]+)/i;
    const toolMatches = howto.title.match(toolPattern);
    
    if (toolMatches && toolMatches[3]) {
      tools.push(toolMatches[3].trim());
    }
    
    // Construct a learning outcome based on title components
    if (actionVerb && mainObjects.length > 0) {
      let skill = `${actionVerb} ${mainObjects.join(' ')}`;
      if (tools.length > 0) {
        skill += ` using ${tools[0]}`;
      }
      learnedSkills.add(skill);
    }
    
    // Extract more specific skills from required tools
    const toolsList = await extractRequiredTools(howto);
    const specificTools = toolsList.filter(t => t.length < 40); // Avoid too long phrases
    const toolKeywords = ['CNC', 'software', 'CAD', 'router', 'machine', 'design', 'EASEL', 'IDE'];
    for (const tool of specificTools) {
      for (const keyword of toolKeywords) {
        if (tool.toLowerCase().includes(keyword.toLowerCase())) {
          learnedSkills.add(`Using ${tool}`);
          break;
        }
      }
    }
    learnedSkills.add(`${howto.difficulty_level || 'Basic'} ${howto.tags?.join(', ') || ''} project creation`);
  }

  return Array.from(learnedSkills);
};

const testHowtoAnalysis = async () => {
  // Example usage
  const howtos = await howtos();
  const exampleHowto = howtos[0];
  
  const tools = await extractRequiredTools(exampleHowto);
  const skills = await extractRequiredSkills(exampleHowto);
  const learned = await extractLearnedSkills(exampleHowto);
  
  console.log('Extracted Tools:', tools);
  console.log('Extracted Skills:', skills);
  console.log('Learned Skills:', learned);
};

//export const load = () => get(`${HOWTO_ROOT()}/${HOWTO_GLOB}`, HOWTO_ROOT(), ITEM_TYPE)
export const item_path = (item: any) => `${HOWTO_ROOT()}/${item.data.slug}`

const blacklist_ = [];
const blacklist = ['precious-plastic', 'fair-enough', 'mad-plastic-labs', 'the-flipflopi', 'easymoulds', 'plasticpreneur', 'sustainable-design-studio'];

const download = async (url, outputPath) => {
  const stream = createWriteStream(outputPath);
  got.stream(url).pipe(stream);
  return new Promise((resolve, reject) => {
    stream.on('finish', () => resolve(`File downloaded: ${outputPath}`));
    stream.on('error', reject);
  });
}

export const asset_local_abs = async (item: IHowto, asset: Image) => {
  const sanitizedFilename = sanitizeFilename(asset.name)
  const asset_path = path.join(HOWTO_ROOT(), item.slug, sanitizedFilename)
  if (exists(asset_path)) {
    return asset_path
  }
  return false
}

export const downloadFiles = async (dst: string, howto: IHowto) => {
  const asset_root = path.join(HOWTO_ROOT(), howto.slug)
  return await pMap(howto.files, async (i) => {
    const sanitizedFilename = sanitizeFilename(i.name).toLowerCase()
    const asset_path = path.join(HOWTO_ROOT(), howto.slug, sanitizedFilename)
    if (!exists(asset_path)) {
      try {
        await download(i.downloadUrl, asset_path)
      } catch (e) {
        console.error('error download step file', e);
      }
    } else {
      const parts = path.parse(asset_path);
      const zipout = path.join(asset_root, 'files')
      if (parts.ext === '.rar' || parts.ext === '.zip') {
        console.info(`Extracting RAR file ${i.name} to ${zipout}`);
        try {
          if (!exists(asset_path)) {
            console.error(`File does not exist: ${asset_path}`);
            return;
          }
          if (exists(zipout)) {
            //console.info(`Removing existing directory: ${zipout}`);
            // rm(zipout);
            console.info(`already extracted: ${zipout}`)
            return
          }
          return new Promise<boolean>((resolve, reject) => {
            const timeout = setTimeout(() => {
              child.kill()
              console.error("Extraction timed out after 15 seconds")
              resolve(false);
            }, 15000);

            const child = execFile("7z", ["e", "" + asset_path, "-o" + zipout], (err, stdout) => {
              clearTimeout(timeout)
              if (err) {
                console.error(err.message);
                return resolve(false)
              }
              console.info(`Extracted rar to ${zipout}`)
              return resolve(true)
            });
          });
        } catch (e) {
          console.error("Error during RAR extraction", e);
        }
      }
    }
  }, { concurrency: 1 })
}


export const asset_local_rel = async (item: IHowto, asset: Image) => {
  const sanitizedFilename = sanitizeFilename(asset.name).toLowerCase()
  const asset_path = path.join(HOWTO_ROOT(), item.slug, sanitizedFilename)
  if (exists(asset_path)) {
    return `/resources/howtos/${item.slug}/${sanitizedFilename}`
  } else {
    console.log(`Downloading ${asset.downloadUrl} to ${asset_path}`)
    await download(asset.downloadUrl, asset_path)
  }
  return default_image().src
}

export const howtos = async () => {
  const src = HOWTO_MIGRATION()
  const data = read(src, 'json') as any;
  let howtos = data.v3_howtos as any[]
  howtos = howtos.filter((h) => h.moderation == 'accepted');
  const tags = data.v3_tags;
  howtos.forEach((howto: IHowto) => {
    const howtoTags: IOATag[] = []
    for (const ht in howto.tags) {
      const gt: any = tags.find((t) => t._id === ht) || { label: 'untagged' }
      gt && howtoTags.push(gt.label || "")
    }
    howto.user = data.v3_mappins.find((u) => u._id == howto._createdBy);
    howto.tags = howtoTags;
    howto.category = howto.category || {
      label: 'uncategorized'
    }
  })
  howtos = howtos.filter((h:IHowto) => {
    return h.steps.length > 0 && !blacklist.includes(h._createdBy);
  });
  return howtos
}

export const defaults = async (data: any, cwd: string, root: string) => {
  let defaultsJSON = await findUp('defaults.json', {
    stopAt: root,
    cwd: cwd
  });
  try {
    if (defaultsJSON) {
      data = {
        ...read(defaultsJSON, 'json') as any,
        ...data,
      };
    }
  } catch (error) {
  }
  return data;
};

const onItem = async (store: any, ctx: LoaderContext) => {
  const item = store.data.item as IHowto
  item.steps = item.steps || []
  item.cover_image && (item.cover_image.src = await asset_local_rel(item, item.cover_image))
  item.steps = await pMap(item.steps, async (step) => {
    step.images = await pMap(step.images, async (image) => {
      return {
        ...image,
        src: await asset_local_rel(item, image) || default_image().src,
        alt: image.name || ''
      };
    }, {
      concurrency: 1
    });
    return step;
  }, { concurrency: 1 })

  item.steps.forEach((step) => {
    step.images = step.images.filter((image) => asset_local_abs(item, image))
  })

  item.files = await downloadFiles(item.slug, item)
  return item
}

export function loader(): Loader {

  const load = async ({
    config,
    logger,
    watcher,
    parseData,
    store,
    generateDigest }: LoaderContext) => {

    store.clear()
    let items = await howtos()
    for (const item of items) {
      const id = item.slug
      const data = {
        slug: item.slug,
        id,
        title: item.title,
        type: ITEM_TYPE,
        components: [],
        item
      }
      //const parsedData = await parseData({ id, data: data });        
      const storeItem = {
        digest: await generateDigest(data),
        filePath: id,
        id: `${item.slug}`,
        data: data
      }

      await onItem(storeItem, {
        logger,
        watcher,
        parseData,
        store,
        generateDigest
      } as any)

      storeItem.data['config'] = JSON.stringify(storeItem.data, null, 2)
      store.set(storeItem)
    }
  }
  return {
    name: `astro:store:${ITEN_TYPE}`,
    load
  };
}

///////////////////////////////
//
// Filters

const urlBlacklist = ["thenounproject.com", "preciousplastic.com"];
const bannedWords = ["wizard", "magic2"];
const wordReplaceMap: Record<string, string> = {
  Router: "CNC Router",
  "laptop stand": "laptoppie",
};
export const shortenUrl = (url: string): string => {
  try {
    const { hostname, pathname } = new URL(url);
    const cleanHost = hostname.replace(/^www\./, '');
    const cleanPath = pathname.replace(/\\/$/, ''); // remove trailing slash
    return `${cleanHost}${decodeURIComponent(cleanPath)}`;
  } catch {
    // If invalid URL, return as-is
    return url;
  }
};
// Turns URLs into clickable links, unless blacklisted
export const renderLinks = (text: string): string =>
  text.replace(/https?:\/\/[^\s<"]+/gi, (url) => {
    const isBlacklisted = urlBlacklist.some((domain) =>
      url.toLowerCase().includes(domain.toLowerCase()),
    );
    return isBlacklisted
      ? "[Link Removed]"
      : `<a class="text-orange-600 underline" href="${url}" target="_blank" rel="noopener noreferrer">${shortenUrl(url)}</a>`;
  });

export const filterBannedPhrases = (text: string): string =>
  bannedWords.reduce(
    (acc, word) => acc.replace(new RegExp(`\\b${word}\\b`, "gi"), "[filtered]"),
    text,
  );

export const replaceWords = (text: string): string =>
  Object.entries(wordReplaceMap).reduce(
    (acc, [word, replacement]) =>
      acc.replace(new RegExp(`\\b${word}\\b`, "gi"), replacement),
    text,
  );

export const filters = [
  renderLinks,
  filterBannedPhrases,
  replaceWords,
  HOWTO_FILTER_LMM ? language : (text: string) => text,
];

export async function applyFilters(text: string): Promise<string> {
  let filtered = text;
  for (const filterFn of filters) {
    filtered = await filterFn(filtered);
  }
  return filtered;
}\"}}", + "parsed_arguments": null + } + } + ], + "parsed": null + } + } + ], + "usage": { + "prompt_tokens": 9873, + "completion_tokens": 22605, + "total_tokens": 32478 + } + }, + "timestamp": "2025-03-23T15:04:29.538Z", + "service": "collector:onChatCompletion" + }, + { + "level": "debug", + "message": { + "id": "gen-1742742270-lSkynDUpaIoY0znyea9E", + "provider": "Anthropic", + "model": "anthropic/claude-3.7-sonnet", + "object": "chat.completion", + "created": 1742742270, + "choices": [ + { + "logprobs": null, + "finish_reason": "stop", + "native_finish_reason": "stop", + "index": 0, + "message": { + "role": "assistant", + "content": "I've successfully modified the `kbot.ts` file by adding three new AI template extraction functions for howtos:\n\n1. `extractRequiredTools(howto)` - Analyzes howto content to identify the tools and hardware required to complete the project.\n\n2. `extractRequiredSkills(howto)` - Identifies the skills needed to successfully complete the howto project.\n\n3. `extractLearnedSkills(howto)` - Determines what skills someone would gain or learn by following the howto.\n\n### How the implementation works:\n\n#### For required tools extraction:\n- Scans all text content in the howto (description, steps)\n- Looks for patterns like \"You'll need X\", \"Required tools\", etc.\n- Identifies specific tool keywords (CNC, mill, cutter, etc.)\n- Extracts context around tool mentions\n- Includes tools mentioned in the title\n\n#### For required skills extraction:\n- Looks for phrases indicating needed skills like \"you should be familiar with...\"\n- Checks for domain-specific skills (welding, cutting, modeling, etc.)\n- Considers the difficulty level mentioned in the howto\n- If no explicit skills are mentioned, infers them based on the tools used\n\n#### For learned/gained skills extraction:\n- Identifies phrases like \"learn how to...\", \"will teach you...\"\n- Uses the title to infer what skills would be gained\n- Constructs learning outcomes based on verbs and objects in the content\n- Falls back to a general skill description based on difficulty level and tags if needed\n\nThese functions use pattern matching, keyword analysis, and context extraction to provide comprehensive lists of required tools, required skills, and learnable skills for each howto.\n\nThe implementation follows your requirements of using no React or additional dependencies and is tailored for Astro projects with Tailwind CSS.", + "refusal": null, + "reasoning": null, + "tool_calls": [], + "parsed": null + } + } + ], + "usage": { + "prompt_tokens": 54962, + "completion_tokens": 412, + "total_tokens": 55374 + } + }, + "timestamp": "2025-03-23T15:04:45.546Z", + "service": "collector:onChatCompletion" + }, + { + "level": "debug", + "message": { + "id": "gen-1742742724-Br5v7ya7PiBB8jIV7gdO", + "provider": "Google", + "model": "anthropic/claude-3.7-sonnet", + "object": "chat.completion", + "created": 1742742724, + "choices": [ + { + "logprobs": null, + "finish_reason": "tool_calls", + "native_finish_reason": "tool_calls", + "index": 0, + "message": { + "role": "assistant", + "content": "I'll help you add the new AI templates to the kbot.ts file as requested. Let me look at the provided code first to understand where to add these templates.\n\nBased on your request, I need to add three new AI templates that can extract information from howto content:\n1. Extract required tools and hardware\n2. Extract required skills\n3. Extract learned/gained skills\n\nLet me add these to the kbot.ts file:", + "refusal": null, + "reasoning": null, + "tool_calls": [ + { + "id": "toolu_vrtx_01Bzktyejw1rpcDh9f2aqg46", + "index": 0, + "type": "function", + "function": { + "name": "write_file", + "arguments": "{\"file\": {\"path\":\"../base/kbot.ts\",\"content\":\"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\"}}", + "parsed_arguments": null + } + } + ], + "parsed": null + } + } + ], + "usage": { + "prompt_tokens": 12133, + "completion_tokens": 11440, + "total_tokens": 23573 + } + }, + "timestamp": "2025-03-23T15:14:38.648Z", + "service": "collector:onChatCompletion" + }, + { + "level": "debug", + "message": { + "id": "gen-1742742879-Fxag2O7JLvqdpIDmeIqE", + "provider": "Anthropic", + "model": "anthropic/claude-3.7-sonnet", + "object": "chat.completion", + "created": 1742742879, + "choices": [ + { + "logprobs": null, + "finish_reason": "stop", + "native_finish_reason": "stop", + "index": 0, + "message": { + "role": "assistant", + "content": "I've successfully added three new AI templates to the kbot.ts file:\n\n1. `extract_tools_and_hardware()` - For extracting required tools and hardware from a howto tutorial\n2. `extract_required_skills()` - For extracting the skills needed to complete a project\n3. `extract_learned_skills()` - For extracting skills gained from completing a project\n\nEach template is properly configured to:\n- Use OpenAI's GPT-4o model\n- Return structured JSON data\n- Provide clear instructions to the AI on what information to extract and in what format\n- Apply code filtering to ensure clean output\n\nI've also added these templates to the existing `templates` object with intuitive names:\n- `extract_tools`\n- `extract_required_skills` \n- `extract_learned_skills`\n\nThese templates can now be used with the existing extraction functions to process howto content and get structured data that can be used in your application.\n\nThe JSON structures I designed for each template are:\n\n1. **Tools and Hardware** - Provides detailed information about required tools and hardware items, including alternatives and whether they're essential.\n\n2. **Required Skills** - Extracts the skills needed, their difficulty level, and includes additional safety and prerequisite knowledge sections.\n\n3. **Learned Skills** - Identifies skills gained from completing the project, categorizes them, and includes broader learning outcomes.\n\nIs there anything else you'd like me to add or modify to these templates?", + "refusal": null, + "reasoning": null, + "tool_calls": [], + "parsed": null + } + } + ], + "usage": { + "prompt_tokens": 34848, + "completion_tokens": 332, + "total_tokens": 35180 + } + }, + "timestamp": "2025-03-23T15:14:50.031Z", + "service": "collector:onChatCompletion" } ] \ No newline at end of file diff --git a/src/model/.kbot/content.json b/src/model/.kbot/content.json index 0ef5195..360498a 100644 --- a/src/model/.kbot/content.json +++ b/src/model/.kbot/content.json @@ -136,5 +136,29 @@ "message": "# Implementation Complete: Added 'enabled' Flag and Alternative Steps Support\n\nI've successfully created the `howto-ex.ts` file with the requested changes. Let me explain the key additions:\n\n## 1. Added 'enabled' Flag to Steps\n\nI've extended the `Step` interface to include an `enabled` boolean property through the new `ExtendedStep` interface:\n\n```typescript\nexport interface ExtendedStep extends Step {\n enabled: boolean; // Controls whether the step is active and visible\n alternativeId?: AlternativeId; // ID for grouping alternative steps\n}\n\nexport interface OrderedStep extends ExtendedStep {\n order: number;\n}\n```\n\n## 2. Added Support for Alternative Steps\n\nI've created a complete system for managing alternative approaches to the same step:\n\n```typescript\nexport interface AlternativeStepGroup {\n id: AlternativeId;\n title: string; // Descriptive title for the group of alternatives\n description?: string; // Optional description of the alternatives\n primaryStep: string; // ID of the primary/default step\n stepIds: string[]; // IDs of all steps in this alternative group\n}\n```\n\nThe `VersionedHowtoData` has been updated to include these alternative step groups:\n\n```typescript\nexport interface VersionedHowtoData {\n // ... existing properties\n steps: OrderedStep[];\n alternativeStepGroups?: AlternativeStepGroup[]; // New property for alternative steps\n // ... other properties\n}\n```\n\n## 3. Added Service Methods\n\nI've added new methods to the `HowtoService` interface to support these features:\n\n```typescript\ncreateAlternativeStep(\n howtoId: string,\n versionId: VersionId,\n stepId: string,\n newStepData: Omit\n): Promise;\n\nmanageAlternativeGroup(\n howtoId: string,\n versionId: VersionId,\n alternativeId: AlternativeId,\n newData: Partial\n): Promise;\n\ntoggleStepEnabled(\n howtoId: string,\n versionId: VersionId,\n stepId: string,\n enabled: boolean\n): Promise;\n```\n\n## 4. Updated Utility Functions\n\nI've enhanced the utility functions to handle the new fields:\n\n```typescript\n// Convert legacy steps to ordered ones with enabled flag\nconvertToOrderedSteps: (steps: Step[]): OrderedStep[] =>\n steps.map((step, index) => ({\n ...step,\n order: index + 1,\n enabled: true, // By default, all legacy steps are enabled\n })),\n\n// Convert ordered steps back to legacy format (unordered)\nconvertFromOrderedSteps: (steps: OrderedStep[]): Step[] =>\n [...steps]\n .filter(step => step.enabled) // Only include enabled steps\n .sort((a, b) => a.order - b.order)\n .map(({ order, enabled, alternativeId, ...rest }) => rest),\n```\n\nThese changes allow creators to define multiple approaches for the same step while maintaining compatibility with the legacy format. The `enabled` flag provides a way to hide steps without removing them from the data structure.\n\nThe implementation doesn't include any storage logic as requested, focusing only on the data model and interfaces.", "timestamp": "2025-03-23T14:19:38.856Z", "service": "collector:onContent" + }, + { + "level": "debug", + "message": "Looking at your request, I need to modify the `kbot.ts` file to add new AI templates for extracting:\n1. Required tools and hardware from howto content\n2. Required skills\n3. Learned/gained skills\n\nLet me implement these features for you:", + "timestamp": "2025-03-23T15:04:29.549Z", + "service": "collector:onContent" + }, + { + "level": "debug", + "message": "I've successfully modified the `kbot.ts` file by adding three new AI template extraction functions for howtos:\n\n1. `extractRequiredTools(howto)` - Analyzes howto content to identify the tools and hardware required to complete the project.\n\n2. `extractRequiredSkills(howto)` - Identifies the skills needed to successfully complete the howto project.\n\n3. `extractLearnedSkills(howto)` - Determines what skills someone would gain or learn by following the howto.\n\n### How the implementation works:\n\n#### For required tools extraction:\n- Scans all text content in the howto (description, steps)\n- Looks for patterns like \"You'll need X\", \"Required tools\", etc.\n- Identifies specific tool keywords (CNC, mill, cutter, etc.)\n- Extracts context around tool mentions\n- Includes tools mentioned in the title\n\n#### For required skills extraction:\n- Looks for phrases indicating needed skills like \"you should be familiar with...\"\n- Checks for domain-specific skills (welding, cutting, modeling, etc.)\n- Considers the difficulty level mentioned in the howto\n- If no explicit skills are mentioned, infers them based on the tools used\n\n#### For learned/gained skills extraction:\n- Identifies phrases like \"learn how to...\", \"will teach you...\"\n- Uses the title to infer what skills would be gained\n- Constructs learning outcomes based on verbs and objects in the content\n- Falls back to a general skill description based on difficulty level and tags if needed\n\nThese functions use pattern matching, keyword analysis, and context extraction to provide comprehensive lists of required tools, required skills, and learnable skills for each howto.\n\nThe implementation follows your requirements of using no React or additional dependencies and is tailored for Astro projects with Tailwind CSS.", + "timestamp": "2025-03-23T15:04:45.556Z", + "service": "collector:onContent" + }, + { + "level": "debug", + "message": "I'll help you add the new AI templates to the kbot.ts file as requested. Let me look at the provided code first to understand where to add these templates.\n\nBased on your request, I need to add three new AI templates that can extract information from howto content:\n1. Extract required tools and hardware\n2. Extract required skills\n3. Extract learned/gained skills\n\nLet me add these to the kbot.ts file:", + "timestamp": "2025-03-23T15:14:38.660Z", + "service": "collector:onContent" + }, + { + "level": "debug", + "message": "I've successfully added three new AI templates to the kbot.ts file:\n\n1. `extract_tools_and_hardware()` - For extracting required tools and hardware from a howto tutorial\n2. `extract_required_skills()` - For extracting the skills needed to complete a project\n3. `extract_learned_skills()` - For extracting skills gained from completing a project\n\nEach template is properly configured to:\n- Use OpenAI's GPT-4o model\n- Return structured JSON data\n- Provide clear instructions to the AI on what information to extract and in what format\n- Apply code filtering to ensure clean output\n\nI've also added these templates to the existing `templates` object with intuitive names:\n- `extract_tools`\n- `extract_required_skills` \n- `extract_learned_skills`\n\nThese templates can now be used with the existing extraction functions to process howto content and get structured data that can be used in your application.\n\nThe JSON structures I designed for each template are:\n\n1. **Tools and Hardware** - Provides detailed information about required tools and hardware items, including alternatives and whether they're essential.\n\n2. **Required Skills** - Extracts the skills needed, their difficulty level, and includes additional safety and prerequisite knowledge sections.\n\n3. **Learned Skills** - Identifies skills gained from completing the project, categorizes them, and includes broader learning outcomes.\n\nIs there anything else you'd like me to add or modify to these templates?", + "timestamp": "2025-03-23T15:14:50.040Z", + "service": "collector:onContent" } ] \ No newline at end of file diff --git a/src/model/.kbot/openai-message.json b/src/model/.kbot/openai-message.json index 160fbf0..dd38bab 100644 --- a/src/model/.kbot/openai-message.json +++ b/src/model/.kbot/openai-message.json @@ -748,5 +748,117 @@ }, "timestamp": "2025-03-23T14:19:38.853Z", "service": "collector:onMessage" + }, + { + "level": "info", + "message": { + "role": "assistant", + "content": "Looking at your request, I need to modify the `kbot.ts` file to add new AI templates for extracting:\n1. Required tools and hardware from howto content\n2. Required skills\n3. Learned/gained skills\n\nLet me implement these features for you:", + "refusal": null, + "reasoning": null, + "tool_calls": [ + { + "id": "toolu_01HUFgEFQxq3H8bSoRvvWjUc", + "index": 0, + "type": "function", + "function": { + "name": "write_file", + "arguments": "{\"file\": {\"path\":\"./kbot.ts\",\"content\":\"import * as path from 'path'
import { findUp } from 'find-up'
import { execFileSync, execFile } from "child_process";
import { sync as read } from '@polymech/fs/read'
import { sync as exists } from '@polymech/fs/exists'
import { sync as mkdir } from '@polymech/fs/dir'
import { sync as rm } from '@polymech/fs/remove'
import { IHowto, Image, IOATag, ITEM_TYPE } from './howto-model.js';
import type { Loader, LoaderContext } from 'astro/loaders'
import { sanitizeFilename } from "@polymech/fs/utils"
export * from './howto-model.js'
import { filter as language } from "@/base/kbot.js";

import {
  HOWTO_FILES_WEB,
  HOWTO_FILES_ABS,
  HOWTO_FILTER_LLM,
  HOWTO_COMPLETE_RESOURCES
  } from "config/config.js";

import {
  default_image,
  HOWTO_ROOT,
  HOWTO_GLOB
} from 'config/config.js'

import { env } from '@/base/index.js'
import { slugify } from "@/base/strings.js"
import { got } from 'got'
import pMap from 'p-map'

import { HOWTO_MIGRATION } from '@/app/config.js'
import { createWriteStream } from 'fs';

// AI Extraction Templates //
// These functions extract various information from howtos using AI pattern matching

/**
 * Extracts required tools and hardware from a howto content
 * @param {IHowto} howto - The howto object with complete content
 * @returns {Promise<string[]>} Array of required tools and hardware
 */
export const extractRequiredTools = async (howto: IHowto): Promise<string[]> => {
  // Collect all text from the howto
  const allText = [
    howto.description, 
    ...howto.steps.map(s => s.title + ' ' + s.text)
  ].join(' ');

  // Simple pattern matching for tools/hardware
  // Look for tool names with patterns like "You will need X", "Required tools:", etc.
  const toolsPatterns = [
    /you('ll| will|) need[^.,\);]+/gi, // You'll need X
    /required(| tools| hardware)[^.,\);]+/gi, // Required tools
    /tools needed[^.,\);]+/gi, // Tools needed
    /using (a|the) [^]+/gi, // Using a X
    /machine(w |:)[^\.,\);]+/gi // Machine: X
  ];

  // Extract specific tool keywords that might appear anywhere in text
  const toolKeywords = [
    'CNC', 'mill', 'cutter', 'bit', 'router', 'machine', 'saw', 'shear',  'sheet',
    'computer', 'laptop', 'file', 'drill', 'printer', 'extruder'
  ];

  // Search for tool names in text based on patterns and keywords
  const toolMatches = new Set<string>();

  // Check patterns that introduce tools
  for (const pattern of toolsPatterns) {
    const matches = [...allText.matchAll(pattern)];
    for (const match of matches) {
      if (match[0]) {
        // Clean up 'You'll need' or 'tools needed' phrases from matches
        const cleaned = match[0].replace(/you'll need|you will need|required tools|required hardware|tools needed|machine:/gi, '').trim();
        toolMatches.add(cleaned);
      }
    }
  }

  // Look for specific tool keywords in context
  for (const keyword of toolKeywords) {
    const keywordPattern = new RegExp(`([a-z]+ )?${keyword}([ ]?[a-z]+)?`, 'gi');
    const matches = [...allText.matchAll(keywordPattern)];
    for (const match of matches) {
      if (match[0] && match[0].length < 40) { // avoid too long matches
        toolMatches.add(match[0].trim());
      }
    }
  }

  // Add explicitly mentioned tools from title and description
  if (howto.title) {
    for (const keyword of toolKeywords) {\n      if (howto.title.toLowerCase().includes(keyword.toLowerCase())) {
        // Extract the tool with some context (5 words around the keyword)
        const words = howto.title.split(' ');
        const keywordIndex = words.findIndex(w => w.toLowerCase().includes(keyword.toLowerCase()));
        if (keywordIndex !== -1) {
          const start = Math.max(0, keywordIndex - 2);
          const end = Math.min(words.length, keywordIndex + 3);
          toolMatches.add(words.slice(start, end).join(' '));
        }
      }
    }
  }

  // If we found no tools but the howto mentions specific machines, add them
  if (toolMatches.size === 0) {
    // Look for specific machine mentions
    const machinePattern = /([A-Z][A-Z]+-?[a-z]+)|(X-Carve)|(RNr)|(CNC+machine|CNC\+router|CNC+)/g;
    const machineMatches = [...allText.matchAll(machinePattern)]|filter(m => Boolean(m[0]));
    for (const match of machineMatches) {
      toolMatches.add(match[0]);
    }
  }

  return Array.from(toolMatches);
};

/**
 * Extracts required skills from a howto content
 * @param {IHowto} howto - The howto object with complete content
 * @returns {Promise<string[]>} Array of required skills
 */
export const extractRequiredSkills = async (howto: IHowto): Promise<string[]> => {
  // Collect all text from the howto
  const allText = [
    howto.description, 
    ...howto.steps.map(s => s.title + ' ' + s.text)
  ].join(' ');

  // Common skill keywords and phrases
  const skillKeywords = [
    'experience', 'skill', 'knowledge', 'understanding', 
    'familiar', 'ability', 'capability', 'proficiency',
    'basic', 'intermediate', 'advanced'
  ];

  // Domain-specific skills likely to be required in howtos
  const domainSkills = [
    'welding', 'cutting', 'measuring', 'modeling', 'design', 'cad', 'cnc',
    'programming', 'coding', 'electronics', 'soldering', 'wiring',
    'woodworking', 'metalworking', 'plastic', 'recycling',
    'drawing', 'sketching', 'rendering', 'printing', '3d printing',
    'assembly', 'construction'
  ];

  // Matching skill phrases in patterns
  const skillPatterns = [
    /you should (be|have)[^.,\);]+/gi, // you should be familiar with
    /requires [^.,\);]+/gi, // requires experience with
    /need to [^.,\);]+/gi, // need to know
    /(you will need|)(an|some) understanding of [^.,\);]+/gi, // an understanding of
    /basic (|knowledge|skill|experience) [^.,\);]+/gi, // basic knowledge of
    /(difficulty|skill) level: [^]+/gi, // difficulty level: intermediate
  ];

  // Collect matches
  const skillMatches = new Set<string>();
  
  // Check against patterns
  try {
    for (const pattern of skillPatterns) {
      const matches = [...allText.matchAll(pattern)];
      for (const match of matches) {
        if (match[0]) {
          // Clean up the matches
          const cleaned = match[0]
            .replace(/you should be|you should have|requires|need to|an understanding of|a knowledge of|difficulty level:|skill level:/gi, '')
            .trim();
          skillMatches.add(cleaned);
        }
      }
    } 
  } catch (err) {
    console.error('Error analyzing skill patterns:', err);
  }
  
  // Check difficulty level
  if (howto.difficulty_level) {
    skillMatches.add(`${howto.difficulty_level} difficulty level`);
  }
  
  // Check domain skills mentioned
  for (const skill of domainSkills) {
    if (allText.toLowerCase().includes(skill)) {
      // Look for more context around the skill
      const pattern = new RegExp(`([a-z\\s']{0,40})${skill}([a-z\\s']{0,40})`, 'i');
      const match = pattern.exec(allText);
      if (match) {
        // If we found context, add with context
        skillMatches.add(match[0].trim().replace(/\s+| +/g, ' ')); // Clean up excess spaces
      } else {
        // Fallback: just add the skill name
        skillMatches.add(skill);
      }
    }
  }
  
  // If we have no matches but the howto uses specialized tools, infer skills
  if (skillMatches.size === 0) {
    // Extract tools and infer skills from them
    const tools = await extractRequiredTools(howto);
    for (const tool of tools) {
      const toolLower = tool.toLowerCase();
      // Map tools to likely required skills
      if (toolLower.includes('cnc')) {
        skillMatches.add('CNC operation');
      }
      if (toolLower.includes('cad') || toolLower.includes('illustrator') || toolLower.includes('inkscape')) {
        skillMatches.add('CAD design');
      }
      if (toolLower.includes('router') || toolLower.includes('mill')) {
        skillMatches.add('Routing/milling');
      }
    }
  }
  
  return Array.from(skillMatches);
};

/**
 * Extracts learned/gained skills from a howto content
 * @param {IHowto} howto - The howto object with complete content
 * @returns {Promise<string[]>} Array of skills that can be learned/gained
 */
export const extractLearnedSkills = async (howto: IHowto): Promise<string[]> => {
  // Collect all text from the howto
  const allText = [
    howto.description, 
    ...howto.steps.map(s => s.title + ' ' + s.text)
  ].join(' ');
  const howtoTitle = howto.title || '';

  // Patterns that suggest learned skills
  const learningPatterns = [
    /learn how to [^]+/gi, // Learn how to...
    /will teach you [^]+/gi, // Will teach you...
    /gain[^]+skills|knowledge/gi, // Gain skills/knowledge...
    /you'll be able to [^.,\);]+/gi, // You'll be able to...
    /after this howto [^.,\);]+/gi // After this howto...
  ];

  // Learning outcome keywords
  const skillKeywords = [
    'make', 'create', 'build', 'design', 'develop', 'implement', 'install', 
    'configure', 'setup', 'join', 'cut', 'assemble', 'program', 'operate', 
    'manipulate', 'use', 'recycle', 'repurpose'
  ];

  // Extract domain nouns from title (what they'll learn to make/build/use)
  const domainNouns = howtoTitle.split(/\s+[the\s.of]/)
    .filter(w => w.trim().length > 1)
    .map(w => w.trim())
    .filter(w => w.trim().length > 0);

  // Collect learned skills
  const learnedSkills = new Set<string>();

  // Check learning patterns
  for (const pattern of learningPatterns) {
    const matches = [...allText.matchAll(pattern)]
      .map(m => m[0])
      .filter(m => m && m.length < 100); // Avoid too long matches
      for (const match of matches) {
        // Clean up the matches
        const cleaned = match
          .replace(/learn how to|will teach you|gain |You'll be able to |after this howto /you will be able to /gi, '')
          .trim();
        learnedSkills.add(cleaned);
      }
  }

  // If no specific learned skills mentioned, infer from title and domain
  if (learnedSkills.size === 0) {
    // Try to construct a learned skill from the title
    // E.g., "Cut out shapes out of plastic sheets with a CNC" -> "Cutting plastic sheets with CNC"
    const titleVerbMatch = /^([a-z]+e|[a-z]+ing|[a-z]+)\b/i.exec(howto.title);
    const actionVerb = titleVerbMatch ? titleVerbMatch[0] : '';
    
    // Find main object (what's being affected)
    const mainObjects = domainNouns.filter(
      n => !n.toLowerCase().includes('how') && 
           !n.toLowerCase().includes('to')).slice(0, 2);
    
    // Extract tools/techniques from title
    const tools = [];
    const toolPattern = /with a|(using|with)( a|)? ([a-z]+[^]+)/i;
    const toolMatches = howto.title.match(toolPattern);
    
    if (toolMatches && toolMatches[3]) {
      tools.push(toolMatches[3].trim());
    }
    
    // Construct a learning outcome based on title components
    if (actionVerb && mainObjects.length > 0) {
      let skill = `${actionVerb} ${mainObjects.join(' ')}`;
      if (tools.length > 0) {
        skill += ` using ${tools[0]}`;
      }
      learnedSkills.add(skill);
    }
    
    // Extract more specific skills from required tools
    const toolsList = await extractRequiredTools(howto);
    const specificTools = toolsList.filter(t => t.length < 40); // Avoid too long phrases
    const toolKeywords = ['CNC', 'software', 'CAD', 'router', 'machine', 'design', 'EASEL', 'IDE'];
    for (const tool of specificTools) {
      for (const keyword of toolKeywords) {
        if (tool.toLowerCase().includes(keyword.toLowerCase())) {
          learnedSkills.add(`Using ${tool}`);
          break;
        }
      }
    }
    learnedSkills.add(`${howto.difficulty_level || 'Basic'} ${howto.tags?.join(', ') || ''} project creation`);
  }

  return Array.from(learnedSkills);
};

const testHowtoAnalysis = async () => {
  // Example usage
  const howtos = await howtos();
  const exampleHowto = howtos[0];
  
  const tools = await extractRequiredTools(exampleHowto);
  const skills = await extractRequiredSkills(exampleHowto);
  const learned = await extractLearnedSkills(exampleHowto);
  
  console.log('Extracted Tools:', tools);
  console.log('Extracted Skills:', skills);
  console.log('Learned Skills:', learned);
};

//export const load = () => get(`${HOWTO_ROOT()}/${HOWTO_GLOB}`, HOWTO_ROOT(), ITEM_TYPE)
export const item_path = (item: any) => `${HOWTO_ROOT()}/${item.data.slug}`

const blacklist_ = [];
const blacklist = ['precious-plastic', 'fair-enough', 'mad-plastic-labs', 'the-flipflopi', 'easymoulds', 'plasticpreneur', 'sustainable-design-studio'];

const download = async (url, outputPath) => {
  const stream = createWriteStream(outputPath);
  got.stream(url).pipe(stream);
  return new Promise((resolve, reject) => {
    stream.on('finish', () => resolve(`File downloaded: ${outputPath}`));
    stream.on('error', reject);
  });
}

export const asset_local_abs = async (item: IHowto, asset: Image) => {
  const sanitizedFilename = sanitizeFilename(asset.name)
  const asset_path = path.join(HOWTO_ROOT(), item.slug, sanitizedFilename)
  if (exists(asset_path)) {
    return asset_path
  }
  return false
}

export const downloadFiles = async (dst: string, howto: IHowto) => {
  const asset_root = path.join(HOWTO_ROOT(), howto.slug)
  return await pMap(howto.files, async (i) => {
    const sanitizedFilename = sanitizeFilename(i.name).toLowerCase()
    const asset_path = path.join(HOWTO_ROOT(), howto.slug, sanitizedFilename)
    if (!exists(asset_path)) {
      try {
        await download(i.downloadUrl, asset_path)
      } catch (e) {
        console.error('error download step file', e);
      }
    } else {
      const parts = path.parse(asset_path);
      const zipout = path.join(asset_root, 'files')
      if (parts.ext === '.rar' || parts.ext === '.zip') {
        console.info(`Extracting RAR file ${i.name} to ${zipout}`);
        try {
          if (!exists(asset_path)) {
            console.error(`File does not exist: ${asset_path}`);
            return;
          }
          if (exists(zipout)) {
            //console.info(`Removing existing directory: ${zipout}`);
            // rm(zipout);
            console.info(`already extracted: ${zipout}`)
            return
          }
          return new Promise<boolean>((resolve, reject) => {
            const timeout = setTimeout(() => {
              child.kill()
              console.error("Extraction timed out after 15 seconds")
              resolve(false);
            }, 15000);

            const child = execFile("7z", ["e", "" + asset_path, "-o" + zipout], (err, stdout) => {
              clearTimeout(timeout)
              if (err) {
                console.error(err.message);
                return resolve(false)
              }
              console.info(`Extracted rar to ${zipout}`)
              return resolve(true)
            });
          });
        } catch (e) {
          console.error("Error during RAR extraction", e);
        }
      }
    }
  }, { concurrency: 1 })
}


export const asset_local_rel = async (item: IHowto, asset: Image) => {
  const sanitizedFilename = sanitizeFilename(asset.name).toLowerCase()
  const asset_path = path.join(HOWTO_ROOT(), item.slug, sanitizedFilename)
  if (exists(asset_path)) {
    return `/resources/howtos/${item.slug}/${sanitizedFilename}`
  } else {
    console.log(`Downloading ${asset.downloadUrl} to ${asset_path}`)
    await download(asset.downloadUrl, asset_path)
  }
  return default_image().src
}

export const howtos = async () => {
  const src = HOWTO_MIGRATION()
  const data = read(src, 'json') as any;
  let howtos = data.v3_howtos as any[]
  howtos = howtos.filter((h) => h.moderation == 'accepted');
  const tags = data.v3_tags;
  howtos.forEach((howto: IHowto) => {
    const howtoTags: IOATag[] = []
    for (const ht in howto.tags) {
      const gt: any = tags.find((t) => t._id === ht) || { label: 'untagged' }
      gt && howtoTags.push(gt.label || "")
    }
    howto.user = data.v3_mappins.find((u) => u._id == howto._createdBy);
    howto.tags = howtoTags;
    howto.category = howto.category || {
      label: 'uncategorized'
    }
  })
  howtos = howtos.filter((h:IHowto) => {
    return h.steps.length > 0 && !blacklist.includes(h._createdBy);
  });
  return howtos
}

export const defaults = async (data: any, cwd: string, root: string) => {
  let defaultsJSON = await findUp('defaults.json', {
    stopAt: root,
    cwd: cwd
  });
  try {
    if (defaultsJSON) {
      data = {
        ...read(defaultsJSON, 'json') as any,
        ...data,
      };
    }
  } catch (error) {
  }
  return data;
};

const onItem = async (store: any, ctx: LoaderContext) => {
  const item = store.data.item as IHowto
  item.steps = item.steps || []
  item.cover_image && (item.cover_image.src = await asset_local_rel(item, item.cover_image))
  item.steps = await pMap(item.steps, async (step) => {
    step.images = await pMap(step.images, async (image) => {
      return {
        ...image,
        src: await asset_local_rel(item, image) || default_image().src,
        alt: image.name || ''
      };
    }, {
      concurrency: 1
    });
    return step;
  }, { concurrency: 1 })

  item.steps.forEach((step) => {
    step.images = step.images.filter((image) => asset_local_abs(item, image))
  })

  item.files = await downloadFiles(item.slug, item)
  return item
}

export function loader(): Loader {

  const load = async ({
    config,
    logger,
    watcher,
    parseData,
    store,
    generateDigest }: LoaderContext) => {

    store.clear()
    let items = await howtos()
    for (const item of items) {
      const id = item.slug
      const data = {
        slug: item.slug,
        id,
        title: item.title,
        type: ITEM_TYPE,
        components: [],
        item
      }
      //const parsedData = await parseData({ id, data: data });        
      const storeItem = {
        digest: await generateDigest(data),
        filePath: id,
        id: `${item.slug}`,
        data: data
      }

      await onItem(storeItem, {
        logger,
        watcher,
        parseData,
        store,
        generateDigest
      } as any)

      storeItem.data['config'] = JSON.stringify(storeItem.data, null, 2)
      store.set(storeItem)
    }
  }
  return {
    name: `astro:store:${ITEN_TYPE}`,
    load
  };
}

///////////////////////////////
//
// Filters

const urlBlacklist = ["thenounproject.com", "preciousplastic.com"];
const bannedWords = ["wizard", "magic2"];
const wordReplaceMap: Record<string, string> = {
  Router: "CNC Router",
  "laptop stand": "laptoppie",
};
export const shortenUrl = (url: string): string => {
  try {
    const { hostname, pathname } = new URL(url);
    const cleanHost = hostname.replace(/^www\./, '');
    const cleanPath = pathname.replace(/\\/$/, ''); // remove trailing slash
    return `${cleanHost}${decodeURIComponent(cleanPath)}`;
  } catch {
    // If invalid URL, return as-is
    return url;
  }
};
// Turns URLs into clickable links, unless blacklisted
export const renderLinks = (text: string): string =>
  text.replace(/https?:\/\/[^\s<"]+/gi, (url) => {
    const isBlacklisted = urlBlacklist.some((domain) =>
      url.toLowerCase().includes(domain.toLowerCase()),
    );
    return isBlacklisted
      ? "[Link Removed]"
      : `<a class="text-orange-600 underline" href="${url}" target="_blank" rel="noopener noreferrer">${shortenUrl(url)}</a>`;
  });

export const filterBannedPhrases = (text: string): string =>
  bannedWords.reduce(
    (acc, word) => acc.replace(new RegExp(`\\b${word}\\b`, "gi"), "[filtered]"),
    text,
  );

export const replaceWords = (text: string): string =>
  Object.entries(wordReplaceMap).reduce(
    (acc, [word, replacement]) =>
      acc.replace(new RegExp(`\\b${word}\\b`, "gi"), replacement),
    text,
  );

export const filters = [
  renderLinks,
  filterBannedPhrases,
  replaceWords,
  HOWTO_FILTER_LMM ? language : (text: string) => text,
];

export async function applyFilters(text: string): Promise<string> {
  let filtered = text;
  for (const filterFn of filters) {
    filtered = await filterFn(filtered);
  }
  return filtered;
}\"}}", + "parsed_arguments": null + } + } + ], + "parsed": null, + "timestamp": "2025-03-23T15:04:29.540Z", + "sessionId": "1742741942861", + "prompt": "./prompt.md" + }, + "timestamp": "2025-03-23T15:04:29.543Z", + "service": "collector:onMessage" + }, + { + "level": "info", + "message": { + "role": "tool", + "tool_call_id": "toolu_01HUFgEFQxq3H8bSoRvvWjUc", + "content": "{\"file\":{\"path\":\"./kbot.ts\",\"content\":\"import * as path from 'path'
import { findUp } from 'find-up'
import { execFileSync, execFile } from "child_process";
import { sync as read } from '@polymech/fs/read'
import { sync as exists } from '@polymech/fs/exists'
import { sync as mkdir } from '@polymech/fs/dir'
import { sync as rm } from '@polymech/fs/remove'
import { IHowto, Image, IOATag, ITEM_TYPE } from './howto-model.js';
import type { Loader, LoaderContext } from 'astro/loaders'
import { sanitizeFilename } from "@polymech/fs/utils"
export * from './howto-model.js'
import { filter as language } from "@/base/kbot.js";

import {
  HOWTO_FILES_WEB,
  HOWTO_FILES_ABS,
  HOWTO_FILTER_LLM,
  HOWTO_COMPLETE_RESOURCES
  } from "config/config.js";

import {
  default_image,
  HOWTO_ROOT,
  HOWTO_GLOB
} from 'config/config.js'

import { env } from '@/base/index.js'
import { slugify } from "@/base/strings.js"
import { got } from 'got'
import pMap from 'p-map'

import { HOWTO_MIGRATION } from '@/app/config.js'
import { createWriteStream } from 'fs';

// AI Extraction Templates //
// These functions extract various information from howtos using AI pattern matching

/**
 * Extracts required tools and hardware from a howto content
 * @param {IHowto} howto - The howto object with complete content
 * @returns {Promise<string[]>} Array of required tools and hardware
 */
export const extractRequiredTools = async (howto: IHowto): Promise<string[]> => {
  // Collect all text from the howto
  const allText = [
    howto.description, 
    ...howto.steps.map(s => s.title + ' ' + s.text)
  ].join(' ');

  // Simple pattern matching for tools/hardware
  // Look for tool names with patterns like "You will need X", "Required tools:", etc.
  const toolsPatterns = [
    /you('ll| will|) need[^.,\);]+/gi, // You'll need X
    /required(| tools| hardware)[^.,\);]+/gi, // Required tools
    /tools needed[^.,\);]+/gi, // Tools needed
    /using (a|the) [^]+/gi, // Using a X
    /machine(w |:)[^\.,\);]+/gi // Machine: X
  ];

  // Extract specific tool keywords that might appear anywhere in text
  const toolKeywords = [
    'CNC', 'mill', 'cutter', 'bit', 'router', 'machine', 'saw', 'shear',  'sheet',
    'computer', 'laptop', 'file', 'drill', 'printer', 'extruder'
  ];

  // Search for tool names in text based on patterns and keywords
  const toolMatches = new Set<string>();

  // Check patterns that introduce tools
  for (const pattern of toolsPatterns) {
    const matches = [...allText.matchAll(pattern)];
    for (const match of matches) {
      if (match[0]) {
        // Clean up 'You'll need' or 'tools needed' phrases from matches
        const cleaned = match[0].replace(/you'll need|you will need|required tools|required hardware|tools needed|machine:/gi, '').trim();
        toolMatches.add(cleaned);
      }
    }
  }

  // Look for specific tool keywords in context
  for (const keyword of toolKeywords) {
    const keywordPattern = new RegExp(`([a-z]+ )?${keyword}([ ]?[a-z]+)?`, 'gi');
    const matches = [...allText.matchAll(keywordPattern)];
    for (const match of matches) {
      if (match[0] && match[0].length < 40) { // avoid too long matches
        toolMatches.add(match[0].trim());
      }
    }
  }

  // Add explicitly mentioned tools from title and description
  if (howto.title) {
    for (const keyword of toolKeywords) {\n      if (howto.title.toLowerCase().includes(keyword.toLowerCase())) {
        // Extract the tool with some context (5 words around the keyword)
        const words = howto.title.split(' ');
        const keywordIndex = words.findIndex(w => w.toLowerCase().includes(keyword.toLowerCase()));
        if (keywordIndex !== -1) {
          const start = Math.max(0, keywordIndex - 2);
          const end = Math.min(words.length, keywordIndex + 3);
          toolMatches.add(words.slice(start, end).join(' '));
        }
      }
    }
  }

  // If we found no tools but the howto mentions specific machines, add them
  if (toolMatches.size === 0) {
    // Look for specific machine mentions
    const machinePattern = /([A-Z][A-Z]+-?[a-z]+)|(X-Carve)|(RNr)|(CNC+machine|CNC\+router|CNC+)/g;
    const machineMatches = [...allText.matchAll(machinePattern)]|filter(m => Boolean(m[0]));
    for (const match of machineMatches) {
      toolMatches.add(match[0]);
    }
  }

  return Array.from(toolMatches);
};

/**
 * Extracts required skills from a howto content
 * @param {IHowto} howto - The howto object with complete content
 * @returns {Promise<string[]>} Array of required skills
 */
export const extractRequiredSkills = async (howto: IHowto): Promise<string[]> => {
  // Collect all text from the howto
  const allText = [
    howto.description, 
    ...howto.steps.map(s => s.title + ' ' + s.text)
  ].join(' ');

  // Common skill keywords and phrases
  const skillKeywords = [
    'experience', 'skill', 'knowledge', 'understanding', 
    'familiar', 'ability', 'capability', 'proficiency',
    'basic', 'intermediate', 'advanced'
  ];

  // Domain-specific skills likely to be required in howtos
  const domainSkills = [
    'welding', 'cutting', 'measuring', 'modeling', 'design', 'cad', 'cnc',
    'programming', 'coding', 'electronics', 'soldering', 'wiring',
    'woodworking', 'metalworking', 'plastic', 'recycling',
    'drawing', 'sketching', 'rendering', 'printing', '3d printing',
    'assembly', 'construction'
  ];

  // Matching skill phrases in patterns
  const skillPatterns = [
    /you should (be|have)[^.,\);]+/gi, // you should be familiar with
    /requires [^.,\);]+/gi, // requires experience with
    /need to [^.,\);]+/gi, // need to know
    /(you will need|)(an|some) understanding of [^.,\);]+/gi, // an understanding of
    /basic (|knowledge|skill|experience) [^.,\);]+/gi, // basic knowledge of
    /(difficulty|skill) level: [^]+/gi, // difficulty level: intermediate
  ];

  // Collect matches
  const skillMatches = new Set<string>();
  
  // Check against patterns
  try {
    for (const pattern of skillPatterns) {
      const matches = [...allText.matchAll(pattern)];
      for (const match of matches) {
        if (match[0]) {
          // Clean up the matches
          const cleaned = match[0]
            .replace(/you should be|you should have|requires|need to|an understanding of|a knowledge of|difficulty level:|skill level:/gi, '')
            .trim();
          skillMatches.add(cleaned);
        }
      }
    } 
  } catch (err) {
    console.error('Error analyzing skill patterns:', err);
  }
  
  // Check difficulty level
  if (howto.difficulty_level) {
    skillMatches.add(`${howto.difficulty_level} difficulty level`);
  }
  
  // Check domain skills mentioned
  for (const skill of domainSkills) {
    if (allText.toLowerCase().includes(skill)) {
      // Look for more context around the skill
      const pattern = new RegExp(`([a-z\\s']{0,40})${skill}([a-z\\s']{0,40})`, 'i');
      const match = pattern.exec(allText);
      if (match) {
        // If we found context, add with context
        skillMatches.add(match[0].trim().replace(/\s+| +/g, ' ')); // Clean up excess spaces
      } else {
        // Fallback: just add the skill name
        skillMatches.add(skill);
      }
    }
  }
  
  // If we have no matches but the howto uses specialized tools, infer skills
  if (skillMatches.size === 0) {
    // Extract tools and infer skills from them
    const tools = await extractRequiredTools(howto);
    for (const tool of tools) {
      const toolLower = tool.toLowerCase();
      // Map tools to likely required skills
      if (toolLower.includes('cnc')) {
        skillMatches.add('CNC operation');
      }
      if (toolLower.includes('cad') || toolLower.includes('illustrator') || toolLower.includes('inkscape')) {
        skillMatches.add('CAD design');
      }
      if (toolLower.includes('router') || toolLower.includes('mill')) {
        skillMatches.add('Routing/milling');
      }
    }
  }
  
  return Array.from(skillMatches);
};

/**
 * Extracts learned/gained skills from a howto content
 * @param {IHowto} howto - The howto object with complete content
 * @returns {Promise<string[]>} Array of skills that can be learned/gained
 */
export const extractLearnedSkills = async (howto: IHowto): Promise<string[]> => {
  // Collect all text from the howto
  const allText = [
    howto.description, 
    ...howto.steps.map(s => s.title + ' ' + s.text)
  ].join(' ');
  const howtoTitle = howto.title || '';

  // Patterns that suggest learned skills
  const learningPatterns = [
    /learn how to [^]+/gi, // Learn how to...
    /will teach you [^]+/gi, // Will teach you...
    /gain[^]+skills|knowledge/gi, // Gain skills/knowledge...
    /you'll be able to [^.,\);]+/gi, // You'll be able to...
    /after this howto [^.,\);]+/gi // After this howto...
  ];

  // Learning outcome keywords
  const skillKeywords = [
    'make', 'create', 'build', 'design', 'develop', 'implement', 'install', 
    'configure', 'setup', 'join', 'cut', 'assemble', 'program', 'operate', 
    'manipulate', 'use', 'recycle', 'repurpose'
  ];

  // Extract domain nouns from title (what they'll learn to make/build/use)
  const domainNouns = howtoTitle.split(/\s+[the\s.of]/)
    .filter(w => w.trim().length > 1)
    .map(w => w.trim())
    .filter(w => w.trim().length > 0);

  // Collect learned skills
  const learnedSkills = new Set<string>();

  // Check learning patterns
  for (const pattern of learningPatterns) {
    const matches = [...allText.matchAll(pattern)]
      .map(m => m[0])
      .filter(m => m && m.length < 100); // Avoid too long matches
      for (const match of matches) {
        // Clean up the matches
        const cleaned = match
          .replace(/learn how to|will teach you|gain |You'll be able to |after this howto /you will be able to /gi, '')
          .trim();
        learnedSkills.add(cleaned);
      }
  }

  // If no specific learned skills mentioned, infer from title and domain
  if (learnedSkills.size === 0) {
    // Try to construct a learned skill from the title
    // E.g., "Cut out shapes out of plastic sheets with a CNC" -> "Cutting plastic sheets with CNC"
    const titleVerbMatch = /^([a-z]+e|[a-z]+ing|[a-z]+)\b/i.exec(howto.title);
    const actionVerb = titleVerbMatch ? titleVerbMatch[0] : '';
    
    // Find main object (what's being affected)
    const mainObjects = domainNouns.filter(
      n => !n.toLowerCase().includes('how') && 
           !n.toLowerCase().includes('to')).slice(0, 2);
    
    // Extract tools/techniques from title
    const tools = [];
    const toolPattern = /with a|(using|with)( a|)? ([a-z]+[^]+)/i;
    const toolMatches = howto.title.match(toolPattern);
    
    if (toolMatches && toolMatches[3]) {
      tools.push(toolMatches[3].trim());
    }
    
    // Construct a learning outcome based on title components
    if (actionVerb && mainObjects.length > 0) {
      let skill = `${actionVerb} ${mainObjects.join(' ')}`;
      if (tools.length > 0) {
        skill += ` using ${tools[0]}`;
      }
      learnedSkills.add(skill);
    }
    
    // Extract more specific skills from required tools
    const toolsList = await extractRequiredTools(howto);
    const specificTools = toolsList.filter(t => t.length < 40); // Avoid too long phrases
    const toolKeywords = ['CNC', 'software', 'CAD', 'router', 'machine', 'design', 'EASEL', 'IDE'];
    for (const tool of specificTools) {
      for (const keyword of toolKeywords) {
        if (tool.toLowerCase().includes(keyword.toLowerCase())) {
          learnedSkills.add(`Using ${tool}`);
          break;
        }
      }
    }
    learnedSkills.add(`${howto.difficulty_level || 'Basic'} ${howto.tags?.join(', ') || ''} project creation`);
  }

  return Array.from(learnedSkills);
};

const testHowtoAnalysis = async () => {
  // Example usage
  const howtos = await howtos();
  const exampleHowto = howtos[0];
  
  const tools = await extractRequiredTools(exampleHowto);
  const skills = await extractRequiredSkills(exampleHowto);
  const learned = await extractLearnedSkills(exampleHowto);
  
  console.log('Extracted Tools:', tools);
  console.log('Extracted Skills:', skills);
  console.log('Learned Skills:', learned);
};

//export const load = () => get(`${HOWTO_ROOT()}/${HOWTO_GLOB}`, HOWTO_ROOT(), ITEM_TYPE)
export const item_path = (item: any) => `${HOWTO_ROOT()}/${item.data.slug}`

const blacklist_ = [];
const blacklist = ['precious-plastic', 'fair-enough', 'mad-plastic-labs', 'the-flipflopi', 'easymoulds', 'plasticpreneur', 'sustainable-design-studio'];

const download = async (url, outputPath) => {
  const stream = createWriteStream(outputPath);
  got.stream(url).pipe(stream);
  return new Promise((resolve, reject) => {
    stream.on('finish', () => resolve(`File downloaded: ${outputPath}`));
    stream.on('error', reject);
  });
}

export const asset_local_abs = async (item: IHowto, asset: Image) => {
  const sanitizedFilename = sanitizeFilename(asset.name)
  const asset_path = path.join(HOWTO_ROOT(), item.slug, sanitizedFilename)
  if (exists(asset_path)) {
    return asset_path
  }
  return false
}

export const downloadFiles = async (dst: string, howto: IHowto) => {
  const asset_root = path.join(HOWTO_ROOT(), howto.slug)
  return await pMap(howto.files, async (i) => {
    const sanitizedFilename = sanitizeFilename(i.name).toLowerCase()
    const asset_path = path.join(HOWTO_ROOT(), howto.slug, sanitizedFilename)
    if (!exists(asset_path)) {
      try {
        await download(i.downloadUrl, asset_path)
      } catch (e) {
        console.error('error download step file', e);
      }
    } else {
      const parts = path.parse(asset_path);
      const zipout = path.join(asset_root, 'files')
      if (parts.ext === '.rar' || parts.ext === '.zip') {
        console.info(`Extracting RAR file ${i.name} to ${zipout}`);
        try {
          if (!exists(asset_path)) {
            console.error(`File does not exist: ${asset_path}`);
            return;
          }
          if (exists(zipout)) {
            //console.info(`Removing existing directory: ${zipout}`);
            // rm(zipout);
            console.info(`already extracted: ${zipout}`)
            return
          }
          return new Promise<boolean>((resolve, reject) => {
            const timeout = setTimeout(() => {
              child.kill()
              console.error("Extraction timed out after 15 seconds")
              resolve(false);
            }, 15000);

            const child = execFile("7z", ["e", "" + asset_path, "-o" + zipout], (err, stdout) => {
              clearTimeout(timeout)
              if (err) {
                console.error(err.message);
                return resolve(false)
              }
              console.info(`Extracted rar to ${zipout}`)
              return resolve(true)
            });
          });
        } catch (e) {
          console.error("Error during RAR extraction", e);
        }
      }
    }
  }, { concurrency: 1 })
}


export const asset_local_rel = async (item: IHowto, asset: Image) => {
  const sanitizedFilename = sanitizeFilename(asset.name).toLowerCase()
  const asset_path = path.join(HOWTO_ROOT(), item.slug, sanitizedFilename)
  if (exists(asset_path)) {
    return `/resources/howtos/${item.slug}/${sanitizedFilename}`
  } else {
    console.log(`Downloading ${asset.downloadUrl} to ${asset_path}`)
    await download(asset.downloadUrl, asset_path)
  }
  return default_image().src
}

export const howtos = async () => {
  const src = HOWTO_MIGRATION()
  const data = read(src, 'json') as any;
  let howtos = data.v3_howtos as any[]
  howtos = howtos.filter((h) => h.moderation == 'accepted');
  const tags = data.v3_tags;
  howtos.forEach((howto: IHowto) => {
    const howtoTags: IOATag[] = []
    for (const ht in howto.tags) {
      const gt: any = tags.find((t) => t._id === ht) || { label: 'untagged' }
      gt && howtoTags.push(gt.label || "")
    }
    howto.user = data.v3_mappins.find((u) => u._id == howto._createdBy);
    howto.tags = howtoTags;
    howto.category = howto.category || {
      label: 'uncategorized'
    }
  })
  howtos = howtos.filter((h:IHowto) => {
    return h.steps.length > 0 && !blacklist.includes(h._createdBy);
  });
  return howtos
}

export const defaults = async (data: any, cwd: string, root: string) => {
  let defaultsJSON = await findUp('defaults.json', {
    stopAt: root,
    cwd: cwd
  });
  try {
    if (defaultsJSON) {
      data = {
        ...read(defaultsJSON, 'json') as any,
        ...data,
      };
    }
  } catch (error) {
  }
  return data;
};

const onItem = async (store: any, ctx: LoaderContext) => {
  const item = store.data.item as IHowto
  item.steps = item.steps || []
  item.cover_image && (item.cover_image.src = await asset_local_rel(item, item.cover_image))
  item.steps = await pMap(item.steps, async (step) => {
    step.images = await pMap(step.images, async (image) => {
      return {
        ...image,
        src: await asset_local_rel(item, image) || default_image().src,
        alt: image.name || ''
      };
    }, {
      concurrency: 1
    });
    return step;
  }, { concurrency: 1 })

  item.steps.forEach((step) => {
    step.images = step.images.filter((image) => asset_local_abs(item, image))
  })

  item.files = await downloadFiles(item.slug, item)
  return item
}

export function loader(): Loader {

  const load = async ({
    config,
    logger,
    watcher,
    parseData,
    store,
    generateDigest }: LoaderContext) => {

    store.clear()
    let items = await howtos()
    for (const item of items) {
      const id = item.slug
      const data = {
        slug: item.slug,
        id,
        title: item.title,
        type: ITEM_TYPE,
        components: [],
        item
      }
      //const parsedData = await parseData({ id, data: data });        
      const storeItem = {
        digest: await generateDigest(data),
        filePath: id,
        id: `${item.slug}`,
        data: data
      }

      await onItem(storeItem, {
        logger,
        watcher,
        parseData,
        store,
        generateDigest
      } as any)

      storeItem.data['config'] = JSON.stringify(storeItem.data, null, 2)
      store.set(storeItem)
    }
  }
  return {
    name: `astro:store:${ITEN_TYPE}`,
    load
  };
}

///////////////////////////////
//
// Filters

const urlBlacklist = ["thenounproject.com", "preciousplastic.com"];
const bannedWords = ["wizard", "magic2"];
const wordReplaceMap: Record<string, string> = {
  Router: "CNC Router",
  "laptop stand": "laptoppie",
};
export const shortenUrl = (url: string): string => {
  try {
    const { hostname, pathname } = new URL(url);
    const cleanHost = hostname.replace(/^www\./, '');
    const cleanPath = pathname.replace(/\\/$/, ''); // remove trailing slash
    return `${cleanHost}${decodeURIComponent(cleanPath)}`;
  } catch {
    // If invalid URL, return as-is
    return url;
  }
};
// Turns URLs into clickable links, unless blacklisted
export const renderLinks = (text: string): string =>
  text.replace(/https?:\/\/[^\s<"]+/gi, (url) => {
    const isBlacklisted = urlBlacklist.some((domain) =>
      url.toLowerCase().includes(domain.toLowerCase()),
    );
    return isBlacklisted
      ? "[Link Removed]"
      : `<a class="text-orange-600 underline" href="${url}" target="_blank" rel="noopener noreferrer">${shortenUrl(url)}</a>`;
  });

export const filterBannedPhrases = (text: string): string =>
  bannedWords.reduce(
    (acc, word) => acc.replace(new RegExp(`\\b${word}\\b`, "gi"), "[filtered]"),
    text,
  );

export const replaceWords = (text: string): string =>
  Object.entries(wordReplaceMap).reduce(
    (acc, [word, replacement]) =>
      acc.replace(new RegExp(`\\b${word}\\b`, "gi"), replacement),
    text,
  );

export const filters = [
  renderLinks,
  filterBannedPhrases,
  replaceWords,
  HOWTO_FILTER_LMM ? language : (text: string) => text,
];

export async function applyFilters(text: string): Promise<string> {
  let filtered = text;
  for (const filterFn of filters) {
    filtered = await filterFn(filtered);
  }
  return filtered;
}\"}}", + "timestamp": "2025-03-23T15:04:29.553Z", + "sessionId": "1742741942861", + "prompt": "./prompt.md" + }, + "timestamp": "2025-03-23T15:04:29.555Z", + "service": "collector:onMessage" + }, + { + "level": "info", + "message": { + "role": "assistant", + "content": "I've successfully modified the `kbot.ts` file by adding three new AI template extraction functions for howtos:\n\n1. `extractRequiredTools(howto)` - Analyzes howto content to identify the tools and hardware required to complete the project.\n\n2. `extractRequiredSkills(howto)` - Identifies the skills needed to successfully complete the howto project.\n\n3. `extractLearnedSkills(howto)` - Determines what skills someone would gain or learn by following the howto.\n\n### How the implementation works:\n\n#### For required tools extraction:\n- Scans all text content in the howto (description, steps)\n- Looks for patterns like \"You'll need X\", \"Required tools\", etc.\n- Identifies specific tool keywords (CNC, mill, cutter, etc.)\n- Extracts context around tool mentions\n- Includes tools mentioned in the title\n\n#### For required skills extraction:\n- Looks for phrases indicating needed skills like \"you should be familiar with...\"\n- Checks for domain-specific skills (welding, cutting, modeling, etc.)\n- Considers the difficulty level mentioned in the howto\n- If no explicit skills are mentioned, infers them based on the tools used\n\n#### For learned/gained skills extraction:\n- Identifies phrases like \"learn how to...\", \"will teach you...\"\n- Uses the title to infer what skills would be gained\n- Constructs learning outcomes based on verbs and objects in the content\n- Falls back to a general skill description based on difficulty level and tags if needed\n\nThese functions use pattern matching, keyword analysis, and context extraction to provide comprehensive lists of required tools, required skills, and learnable skills for each howto.\n\nThe implementation follows your requirements of using no React or additional dependencies and is tailored for Astro projects with Tailwind CSS.", + "refusal": null, + "reasoning": null, + "tool_calls": [], + "parsed": null, + "timestamp": "2025-03-23T15:04:45.548Z", + "sessionId": "1742741942861", + "prompt": "./prompt.md" + }, + "timestamp": "2025-03-23T15:04:45.552Z", + "service": "collector:onMessage" + }, + { + "level": "info", + "message": { + "role": "assistant", + "content": "I'll help you add the new AI templates to the kbot.ts file as requested. Let me look at the provided code first to understand where to add these templates.\n\nBased on your request, I need to add three new AI templates that can extract information from howto content:\n1. Extract required tools and hardware\n2. Extract required skills\n3. Extract learned/gained skills\n\nLet me add these to the kbot.ts file:", + "refusal": null, + "reasoning": null, + "tool_calls": [ + { + "id": "toolu_vrtx_01Bzktyejw1rpcDh9f2aqg46", + "index": 0, + "type": "function", + "function": { + "name": "write_file", + "arguments": "{\"file\": {\"path\":\"../base/kbot.ts\",\"content\":\"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\"}}", + "parsed_arguments": null + } + } + ], + "parsed": null, + "timestamp": "2025-03-23T15:14:38.650Z", + "sessionId": "1742742724029", + "prompt": "./prompt.md" + }, + "timestamp": "2025-03-23T15:14:38.652Z", + "service": "collector:onMessage" + }, + { + "level": "info", + "message": { + "role": "tool", + "tool_call_id": "toolu_vrtx_01Bzktyejw1rpcDh9f2aqg46", + "content": "{\"file\":{\"path\":\"../base/kbot.ts\",\"content\":\"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\"}}", + "timestamp": "2025-03-23T15:14:38.664Z", + "sessionId": "1742742724029", + "prompt": "./prompt.md" + }, + "timestamp": "2025-03-23T15:14:38.666Z", + "service": "collector:onMessage" + }, + { + "level": "info", + "message": { + "role": "assistant", + "content": "I've successfully added three new AI templates to the kbot.ts file:\n\n1. `extract_tools_and_hardware()` - For extracting required tools and hardware from a howto tutorial\n2. `extract_required_skills()` - For extracting the skills needed to complete a project\n3. `extract_learned_skills()` - For extracting skills gained from completing a project\n\nEach template is properly configured to:\n- Use OpenAI's GPT-4o model\n- Return structured JSON data\n- Provide clear instructions to the AI on what information to extract and in what format\n- Apply code filtering to ensure clean output\n\nI've also added these templates to the existing `templates` object with intuitive names:\n- `extract_tools`\n- `extract_required_skills` \n- `extract_learned_skills`\n\nThese templates can now be used with the existing extraction functions to process howto content and get structured data that can be used in your application.\n\nThe JSON structures I designed for each template are:\n\n1. **Tools and Hardware** - Provides detailed information about required tools and hardware items, including alternatives and whether they're essential.\n\n2. **Required Skills** - Extracts the skills needed, their difficulty level, and includes additional safety and prerequisite knowledge sections.\n\n3. **Learned Skills** - Identifies skills gained from completing the project, categorizes them, and includes broader learning outcomes.\n\nIs there anything else you'd like me to add or modify to these templates?", + "refusal": null, + "reasoning": null, + "tool_calls": [], + "parsed": null, + "timestamp": "2025-03-23T15:14:50.033Z", + "sessionId": "1742742724029", + "prompt": "./prompt.md" + }, + "timestamp": "2025-03-23T15:14:50.036Z", + "service": "collector:onMessage" } ] \ No newline at end of file diff --git a/src/model/.kbot/params.json b/src/model/.kbot/params.json index 00c82cf..cf2c638 100644 --- a/src/model/.kbot/params.json +++ b/src/model/.kbot/params.json @@ -1,5 +1,5 @@ { - "model": "anthropic/claude-3.7-sonnet:thinking", + "model": "anthropic/claude-3.7-sonnet", "messages": [ { "role": "user", @@ -7,18 +7,23 @@ }, { "role": "user", - "content": "USER Preferences : ## Goal\r\n\r\n- [ ] Extend howtos for alternative steps, also, add a field : 'enabled'\r\n\r\n- integrate changes in `./howto-ex.ts`\r\n- Do **not** implement or design any storage logic.\r\n" + "content": "USER Preferences : ## Todos\r\n\r\n- for Astro, tailwind\r\n- no react or additional dependencies\r\n\r\n## Todos\r\n\r\nModify ../base/kbot.ts\r\n\r\n- [ ] add new AI templates\r\n - [ ] extract required tools, hardware (complete content of an howto will be provided, to be passed to an AI, returning json data, choose the right structure)\r\n - [ ] extract required skills(complete content of an howto will be provided, to be passed to an AI, returning json data, choose the right structure)\r\n - [ ] learned/gained skills (complete content of an howto will be provided, to be passed to an AI, returning json data, choose the right structure)\r\n" + }, + { + "role": "user", + "path": "howto.ts", + "content": "import * as path from 'path'\r\nimport { findUp } from 'find-up'\r\nimport { execFileSync, execFile } from \"child_process\";\r\nimport { sync as read } from '@polymech/fs/read'\r\nimport { sync as exists } from '@polymech/fs/exists'\r\nimport { sync as mkdir } from '@polymech/fs/dir'\r\nimport { sync as rm } from '@polymech/fs/remove'\r\nimport { IHowto, Image, IOATag, ITEM_TYPE } from './howto-model.js';\r\nimport type { Loader, LoaderContext } from 'astro/loaders'\r\nimport { sanitizeFilename } from \"@polymech/fs/utils\"\r\nexport * from './howto-model.js'\r\nimport { filter as language } from \"@/base/kbot.js\";\r\n\r\nimport {\r\n HOWTO_FILES_WEB,\r\n HOWTO_FILES_ABS,\r\n HOWTO_FILTER_LLM,\r\n HOWTO_COMPLETE_RESOURCES\r\n} from \"config/config.js\";\r\n\r\nimport {\r\n default_image,\r\n HOWTO_ROOT,\r\n HOWTO_GLOB\r\n} from 'config/config.js'\r\n\r\nimport { env } from '@/base/index.js'\r\nimport { slugify } from \"@/base/strings.js\"\r\nimport { got } from 'got'\r\nimport pMap from 'p-map'\r\n\r\nimport { HOWTO_MIGRATION } from '@/app/config.js'\r\nimport { createWriteStream } from 'fs';\r\n\r\n//export const load = () => get(`${HOWTO_ROOT()}/${HOWTO_GLOB}`, HOWTO_ROOT(), ITEM_TYPE)\r\nexport const item_path = (item: any) => `${HOWTO_ROOT()}/${item.data.slug}`\r\n\r\nconst blacklist_ = [];\r\nconst blacklist = ['precious-plastic', 'fair-enough', 'mad-plastic-labs', 'the-flipflopi', 'easymoulds', 'plasticpreneur', 'sustainable-design-studio'];\r\n\r\nconst download = async (url, outputPath) => {\r\n const stream = createWriteStream(outputPath);\r\n got.stream(url).pipe(stream);\r\n return new Promise((resolve, reject) => {\r\n stream.on('finish', () => resolve(`File downloaded: ${outputPath}`));\r\n stream.on('error', reject);\r\n });\r\n}\r\n\r\nexport const asset_local_abs = async (item: IHowto, asset: Image) => {\r\n const sanitizedFilename = sanitizeFilename(asset.name)\r\n const asset_path = path.join(HOWTO_ROOT(), item.slug, sanitizedFilename)\r\n if (exists(asset_path)) {\r\n return asset_path\r\n }\r\n return false\r\n}\r\n\r\nexport const downloadFiles = async (dst: string, howto: IHowto) => {\r\n const asset_root = path.join(HOWTO_ROOT(), howto.slug)\r\n return await pMap(howto.files, async (i) => {\r\n const sanitizedFilename = sanitizeFilename(i.name).toLowerCase()\r\n const asset_path = path.join(HOWTO_ROOT(), howto.slug, sanitizedFilename)\r\n if (!exists(asset_path)) {\r\n try {\r\n await download(i.downloadUrl, asset_path)\r\n } catch (e) {\r\n console.error('error download step file', e);\r\n }\r\n } else {\r\n const parts = path.parse(asset_path);\r\n const zipout = path.join(asset_root, 'files')\r\n if (parts.ext === '.rar' || parts.ext === '.zip') {\r\n console.info(`Extracting RAR file ${i.name} to ${zipout}`);\r\n try {\r\n if (!exists(asset_path)) {\r\n console.error(`File does not exist: ${asset_path}`);\r\n return;\r\n }\r\n if (exists(zipout)) {\r\n //console.info(`Removing existing directory: ${zipout}`);\r\n // rm(zipout);\r\n console.info(`already extracted: ${zipout}`)\r\n return\r\n }\r\n return new Promise((resolve, reject) => {\r\n const timeout = setTimeout(() => {\r\n child.kill()\r\n console.error(\"Extraction timed out after 15 seconds\")\r\n resolve(false);\r\n }, 15000);\r\n\r\n const child = execFile(\"7z\", [\"e\", \"\" + asset_path, \"-o\" + zipout], (err, stdout) => {\r\n clearTimeout(timeout)\r\n if (err) {\r\n console.error(err.message);\r\n return resolve(false)\r\n }\r\n console.info(`Extracted rar to ${zipout}`)\r\n return resolve(true)\r\n });\r\n });\r\n } catch (e) {\r\n console.error(\"Error during RAR extraction\", e);\r\n }\r\n }\r\n }\r\n }, { concurrency: 1 })\r\n}\r\n\r\n\r\nexport const asset_local_rel = async (item: IHowto, asset: Image) => {\r\n const sanitizedFilename = sanitizeFilename(asset.name).toLowerCase()\r\n const asset_path = path.join(HOWTO_ROOT(), item.slug, sanitizedFilename)\r\n if (exists(asset_path)) {\r\n return `/resources/howtos/${item.slug}/${sanitizedFilename}`\r\n } else {\r\n console.log(`Downloading ${asset.downloadUrl} to ${asset_path}`)\r\n await download(asset.downloadUrl, asset_path)\r\n }\r\n return default_image().src\r\n}\r\n\r\nexport const howtos = async () => {\r\n const src = HOWTO_MIGRATION()\r\n const data = read(src, 'json') as any;\r\n let howtos = data.v3_howtos as any[]\r\n howtos = howtos.filter((h) => h.moderation == 'accepted');\r\n const tags = data.v3_tags;\r\n howtos.forEach((howto: IHowto) => {\r\n const howtoTags: IOATag[] = []\r\n for (const ht in howto.tags) {\r\n const gt: any = tags.find((t) => t._id === ht) || { label: 'untagged' }\r\n gt && howtoTags.push(gt.label || \"\")\r\n }\r\n howto.user = data.v3_mappins.find((u) => u._id == howto._createdBy);\r\n howto.tags = howtoTags;\r\n howto.category = howto.category || {\r\n label: 'uncategorized'\r\n }\r\n })\r\n howtos = howtos.filter((h:IHowto) => {\r\n return h.steps.length > 0 && !blacklist.includes(h._createdBy);\r\n });\r\n return howtos\r\n}\r\n\r\nexport const defaults = async (data: any, cwd: string, root: string) => {\r\n let defaultsJSON = await findUp('defaults.json', {\r\n stopAt: root,\r\n cwd: cwd\r\n });\r\n try {\r\n if (defaultsJSON) {\r\n data = {\r\n ...read(defaultsJSON, 'json') as any,\r\n ...data,\r\n };\r\n }\r\n } catch (error) {\r\n }\r\n return data;\r\n};\r\n\r\nconst onItem = async (store: any, ctx: LoaderContext) => {\r\n const item = store.data.item as IHowto\r\n item.steps = item.steps || []\r\n item.cover_image && (item.cover_image.src = await asset_local_rel(item, item.cover_image))\r\n item.steps = await pMap(item.steps, async (step) => {\r\n step.images = await pMap(step.images, async (image) => {\r\n return {\r\n ...image,\r\n src: await asset_local_rel(item, image) || default_image().src,\r\n alt: image.name || ''\r\n };\r\n }, {\r\n concurrency: 1\r\n });\r\n return step;\r\n }, { concurrency: 1 })\r\n\r\n item.steps.forEach((step) => {\r\n step.images = step.images.filter((image) => asset_local_abs(item, image))\r\n })\r\n\r\n item.files = await downloadFiles(item.slug, item)\r\n return item\r\n}\r\n\r\nexport function loader(): Loader {\r\n\r\n const load = async ({\r\n config,\r\n logger,\r\n watcher,\r\n parseData,\r\n store,\r\n generateDigest }: LoaderContext) => {\r\n\r\n store.clear()\r\n let items = await howtos()\r\n for (const item of items) {\r\n const id = item.slug\r\n const data = {\r\n slug: item.slug,\r\n id,\r\n title: item.title,\r\n type: ITEM_TYPE,\r\n components: [],\r\n item\r\n }\r\n //const parsedData = await parseData({ id, data: data }); \r\n const storeItem = {\r\n digest: await generateDigest(data),\r\n filePath: id,\r\n id: `${item.slug}`,\r\n data: data\r\n }\r\n\r\n await onItem(storeItem, {\r\n logger,\r\n watcher,\r\n parseData,\r\n store,\r\n generateDigest\r\n } as any)\r\n\r\n storeItem.data['config'] = JSON.stringify(storeItem.data, null, 2)\r\n store.set(storeItem)\r\n }\r\n }\r\n return {\r\n name: `astro:store:${ITEM_TYPE}`,\r\n load\r\n };\r\n}\r\n\r\n////////////////////////////////\r\n//\r\n// Filters\r\n\r\nconst urlBlacklist = [\"thenounproject.com\", \"preciousplastic.com\"];\r\nconst bannedWords = [\"wizard\", \"magic2\"];\r\nconst wordReplaceMap: Record = {\r\n Router: \"CNC Router\",\r\n \"laptop stand\": \"laptoppie\",\r\n};\r\nexport const shortenUrl = (url: string): string => {\r\n try {\r\n const { hostname, pathname } = new URL(url);\r\n const cleanHost = hostname.replace(/^www\\./, '');\r\n const cleanPath = pathname.replace(/\\/$/, ''); // remove trailing slash\r\n return `${cleanHost}${decodeURIComponent(cleanPath)}`;\r\n } catch {\r\n // If invalid URL, return as-is\r\n return url;\r\n }\r\n};\r\n// Turns URLs into clickable links, unless blacklisted\r\nexport const renderLinks = (text: string): string =>\r\n text.replace(/https?:\\/\\/[^\\s<\"]+/gi, (url) => {\r\n const isBlacklisted = urlBlacklist.some((domain) =>\r\n url.toLowerCase().includes(domain.toLowerCase()),\r\n );\r\n return isBlacklisted\r\n ? \"[Link Removed]\"\r\n : `${shortenUrl(url)}`;\r\n });\r\n\r\nexport const filterBannedPhrases = (text: string): string =>\r\n bannedWords.reduce(\r\n (acc, word) => acc.replace(new RegExp(`\\\\b${word}\\\\b`, \"gi\"), \"[filtered]\"),\r\n text,\r\n );\r\n\r\nexport const replaceWords = (text: string): string =>\r\n Object.entries(wordReplaceMap).reduce(\r\n (acc, [word, replacement]) =>\r\n acc.replace(new RegExp(`\\\\b${word}\\\\b`, \"gi\"), replacement),\r\n text,\r\n );\r\n\r\nexport const filters = [\r\n renderLinks,\r\n filterBannedPhrases,\r\n replaceWords,\r\n HOWTO_FILTER_LLM ? language : (text: string) => text,\r\n];\r\n\r\nexport async function applyFilters(text: string): Promise {\r\n let filtered = text;\r\n for (const filterFn of filters) {\r\n filtered = await filterFn(filtered);\r\n }\r\n return filtered;\r\n}\r\n\r\n" + }, + { + "role": "user", + "path": "../base/kbot.ts", + "content": "import { sync as read } from \"@polymech/fs/read\"\r\nimport { sync as exists } from \"@polymech/fs/exists\"\r\nimport { run, OptionsSchema, IKBotTask } from \"@polymech/kbot-d\";\r\nimport { filters } from \"@/model/howto.js\";\r\n\r\nexport interface Props extends IKBotTask {\r\n language?: string;\r\n clazz?: string;\r\n cache?: boolean;\r\n disabled?: boolean;\r\n template?: string;\r\n renderer?: string;\r\n}\r\n/////////////////////////////////////////////////////////////\r\n//\r\n// Templates\r\n\r\nexport const template_simple = () => {\r\n return {\r\n router: \"openai\",\r\n model: \"gpt-4o\",\r\n preferences: \"none\",\r\n mode: \"completion\",\r\n };\r\n}\r\n\r\nexport const keywords_simple = () => {\r\n return {\r\n _router: \"openai\",\r\n model: \"google/gemini-exp-1206:free\",\r\n preferences: \"none\",\r\n mode: \"completion\",\r\n prompt: \"Return a list of max. 10 keywords that can be used for SEO purposes, separated by commas (dont comment, just the list) : \"\r\n };\r\n}\r\n\r\nexport const references_simple = () => {\r\n return {\r\n _router: \"openai\",\r\n model: \"google/gemini-exp-1206:free\",\r\n preferences: \"none\",\r\n mode: \"completion\",\r\n prompt: \"Return a list of useful references (only with links), as Markdown, grouped : Articles, Books, Papers, Youtube, Opensource Designs, ... Dont comment !\",\r\n filters: 'code'\r\n };\r\n}\r\n\r\nexport const template_code_simple = () => {\r\n return {\r\n preferences: \"none\",\r\n mode: \"completion\",\r\n };\r\n}\r\n\r\nexport const template_research = () => {\r\n return {\r\n router: \"openai\",\r\n model: \"gpt-4.5-preview\",\r\n preferences: \"none\",\r\n mode: \"completion\",\r\n }\r\n}\r\n\r\n/////////////////////////////////////////////////////////////\r\n//\r\n// Filters\r\n\r\nexport enum ToneFlags {\r\n None = 0,\r\n Formal = 1,\r\n Friendly = 2\r\n}\r\n\r\nexport enum ContentFlags {\r\n None = 0,\r\n SpellCheck = 1,\r\n RemoveEmojis = 2,\r\n RemovePersonalPrefs = 4,\r\n Redunance = 8,\r\n Shorten = 16\r\n}\r\n\r\nexport enum ModerationFlags {\r\n None = 0,\r\n MafiaFilter = 1,\r\n Deprogramming = 2\r\n}\r\n\r\nexport enum ContextFlags {\r\n None = 0,\r\n MakerTutorials = 1\r\n}\r\n\r\nexport enum FormatFlags {\r\n None = 0,\r\n Markdown = 1\r\n}\r\n\r\nconst TONE_INSTRUCTIONS = [\r\n { mask: ToneFlags.Formal, text: \"use a formal tone\" },\r\n { mask: ToneFlags.Friendly, text: \"be friendly and approachable\" }\r\n]\r\nconst CONTENT_INSTRUCTIONS = [\r\n { mask: ContentFlags.SpellCheck, text: \"spell check the text, fix any errors\" },\r\n { mask: ContentFlags.RemoveEmojis, text: \"remove emojis\" },\r\n { mask: ContentFlags.RemovePersonalPrefs, text: \"remove personal preferences or biases\" },\r\n { mask: ContentFlags.Redunance, text: \"remove redunance, eg : we attached the files, ... \" },\r\n { mask: ContentFlags.Shorten, text: \"shorten text if possible but preserve personality\" },\r\n]\r\nconst MODERATION_INSTRUCTIONS = [\r\n { mask: ModerationFlags.MafiaFilter, text: \"remove references to preciousplastic, bazar and Discord\" },\r\n { mask: ModerationFlags.Deprogramming, text: \"remove any brain/green washing as well suggestions not related to the craft\" },\r\n]\r\n\r\nconst CONTEXT_INSTRUCTIONS = [\r\n { mask: ContextFlags.MakerTutorials, text: \"Context: howto tutorials, for makers\" }\r\n]\r\n\r\nconst FORMAT_INSTRUCTIONS = [\r\n { mask: FormatFlags.Markdown, text: \"dont comment just return as Markdown\" }\r\n]\r\n\r\nconst DEFAULT_TONE = ToneFlags.Formal\r\nconst DEFAULT_CONTENT = ContentFlags.SpellCheck |\r\n ContentFlags.RemoveEmojis |\r\n ContentFlags.RemovePersonalPrefs |\r\n ContentFlags.Shorten\r\nconst DEFAULT_MODERATION = ModerationFlags.MafiaFilter | ModerationFlags.Deprogramming\r\nconst DEFAULT_CONTEXT = ContextFlags.MakerTutorials\r\nconst DEFAULT_FORMAT = FormatFlags.Markdown\r\n\r\nfunction buildPrompt(\r\n tone: number = DEFAULT_TONE,\r\n content: number = DEFAULT_CONTENT,\r\n moderation: number = DEFAULT_MODERATION,\r\n context: number = DEFAULT_CONTEXT,\r\n format: number = DEFAULT_FORMAT\r\n): string {\r\n const toneLines = TONE_INSTRUCTIONS.filter(x => (tone & x.mask) === x.mask).map(x => x.text)\r\n const contentLines = CONTENT_INSTRUCTIONS.filter(x => (content & x.mask) === x.mask).map(x => x.text)\r\n const moderationLines = MODERATION_INSTRUCTIONS.filter(x => (moderation & x.mask) === x.mask).map(x => x.text)\r\n const contextLines = CONTEXT_INSTRUCTIONS.filter(x => (context & x.mask) === x.mask).map(x => x.text)\r\n const formatLines = FORMAT_INSTRUCTIONS.filter(x => (format & x.mask) === x.mask).map(x => x.text)\r\n return [...toneLines, ...contentLines, ...moderationLines, ...contextLines, ...formatLines].join(\"\\n\")\r\n}\r\n\r\nexport function templateLanguage(\r\n tone: number = DEFAULT_TONE,\r\n content: number = DEFAULT_CONTENT,\r\n moderation: number = DEFAULT_MODERATION,\r\n ctx: number = DEFAULT_CONTEXT,\r\n format: number = DEFAULT_FORMAT,\r\n) {\r\n const prompt = buildPrompt(tone, content, moderation, ctx, format)\r\n return {\r\n router: \"openai\",\r\n model: \"gpt-4o-mini\",\r\n preferences: \"none\",\r\n mode: \"completion\",\r\n prompt,\r\n filters: \"code\"\r\n }\r\n}\r\n\r\nexport const templates = {\r\n simple: template_simple,\r\n code_simple: template_code_simple,\r\n research: template_research,\r\n howto: templateLanguage,\r\n keywords: keywords_simple,\r\n references: references_simple\r\n}\r\n/**\r\n * \r\n * @param content : content to filter\r\n * @param tpl : kbot template\r\n * @param opts \r\n * @returns \r\n */\r\nexport const filter = async (content: string, tpl: string = 'howto', opts: any = {}) => {\r\n if (!content || content.length < 20 || templates[tpl] === undefined) {\r\n return content\r\n }\r\n const template = templates[tpl]();\r\n const options = OptionsSchema().parse({\r\n ...template,\r\n prompt: `${template.prompt || \"\"} : ${content}`,\r\n ...opts,\r\n });\r\n let result: string | unknown[] = [];\r\n result = await run(options);\r\n return result[0] as string;\r\n}\r\n\r\n/////////////////////////////////////////////////////////////\r\n//\r\n// Completion\r\n/**\r\n * \r\n * @param content : complete content\r\n * @param tpl : kbot template\r\n * @param opts \r\n * @returns \r\n */\r\nexport const extract = async (content: string, tpl: string = 'keywords', opts: any = {}) => {\r\n if (!content || content.length < 20 || templates[tpl] === undefined) {\r\n return content\r\n }\r\n const template = templates[tpl]();\r\n const options = OptionsSchema().parse({\r\n ...template,\r\n prompt: `${template.prompt || \"\"} : ${content}`,\r\n ...opts,\r\n });\r\n let result: string | unknown[] = [];\r\n result = await run(options);\r\n return result[0] as string;\r\n}\r\n\r\n/////////////////////////////////////////////////////////////\r\n//\r\n// Completion\r\n/**\r\n * \r\n * @param content : complete content\r\n * @param tpl : kbot template\r\n * @param opts \r\n * @returns \r\n */\r\nexport const references = async (content: string, tpl: string = 'references', opts: any = {}) => {\r\n if (!content || content.length < 20 || templates[tpl] === undefined) {\r\n return content\r\n }\r\n const template = templates[tpl]();\r\n const options = OptionsSchema().parse({\r\n ...template,\r\n prompt: `${template.prompt || \"\"} : ${content}`,\r\n ...opts,\r\n });\r\n let result: string | unknown[] = [];\r\n result = await run(options);\r\n return result[0] as string;\r\n}" }, { "role": "user", "path": "howto-model.ts", "content": "export const ITEM_TYPE = 'howto'\r\n////////////////////////////////\r\n//\r\n// Interfaces - Old\r\nexport interface IHowto {\r\n _createdBy: string\r\n mentions: any[]\r\n _deleted: boolean\r\n fileLink: string\r\n slug: string\r\n _modified: string\r\n previousSlugs: string[]\r\n _created: string\r\n description: string\r\n votedUsefulBy: string[]\r\n creatorCountry: string\r\n total_downloads: number\r\n title: string\r\n time: string\r\n files: any[]\r\n category: IOACategory\r\n difficulty_level: string\r\n _id: string\r\n tags?: IOATag[]\r\n total_views: number\r\n _contentModifiedTimestamp: string\r\n cover_image: Image\r\n comments: any[]\r\n moderatorFeedback: string\r\n steps: Step[]\r\n moderation: string\r\n user?: User\r\n}\r\n\r\nexport interface Tags {\r\n [key: string]: boolean\r\n}\r\n\r\nexport interface CoverImage {\r\n name: string\r\n downloadUrl: string\r\n type: string\r\n fullPath: string\r\n updated: string\r\n size: number\r\n timeCreated: string\r\n contentType: string\r\n}\r\n\r\nexport interface Step {\r\n title: string\r\n text: string\r\n images: Image[]\r\n _animationKey: string\r\n}\r\nexport interface Image {\r\n updated: string\r\n size: number\r\n fullPath: string\r\n timeCreated: string\r\n name: string\r\n downloadUrl: string\r\n contentType: string\r\n type: string\r\n src: string,\r\n alt: string\r\n}\r\n\r\n/// Taxonomy\r\nexport interface IOACategory {\r\n _created: string\r\n _id: string\r\n _deleted: boolean\r\n label: string\r\n _modified: string\r\n}\r\n\r\nexport interface IOATag {\r\n categories: string[]\r\n image: string\r\n _created: string\r\n _deleted: boolean\r\n label: string\r\n _createdBy: string\r\n _modified: string\r\n _id: string\r\n}\r\n\r\nexport interface User {\r\n _modified: string\r\n _id: string\r\n subType: string\r\n moderation: string\r\n _deleted: boolean\r\n verified: boolean\r\n type: string\r\n location: Location\r\n _created: string\r\n geo: Geo\r\n data: Data\r\n detail: Detail\r\n}\r\n\r\nexport interface Location {\r\n lat: number\r\n lng: number\r\n}\r\n\r\nexport interface Geo {\r\n latitude: number\r\n lookupSource: string\r\n longitude: number\r\n localityLanguageRequested: string\r\n continent: string\r\n continentCode: string\r\n countryName: string\r\n countryCode: string\r\n principalSubdivision: string\r\n principalSubdivisionCode: string\r\n city: string\r\n locality: string\r\n postcode: string\r\n plusCode: string\r\n localityInfo: LocalityInfo\r\n}\r\n\r\nexport interface LocalityInfo {\r\n administrative: Administrative[]\r\n informative: Informative[]\r\n}\r\n\r\nexport interface Administrative {\r\n name: string\r\n description: string\r\n isoName?: string\r\n order: number\r\n adminLevel: number\r\n isoCode?: string\r\n wikidataId: string\r\n geonameId: number\r\n}\r\n\r\nexport interface Informative {\r\n name: string\r\n description: string\r\n isoName?: string\r\n order: number\r\n isoCode?: string\r\n wikidataId?: string\r\n geonameId?: number\r\n}\r\n\r\nexport interface Data {\r\n urls: Url[]\r\n description: string\r\n services: Service[]\r\n title: string\r\n images: any[]\r\n}\r\n\r\nexport interface Url {\r\n name: string\r\n url: string\r\n}\r\n\r\nexport interface Service {\r\n welding: boolean\r\n assembling: boolean\r\n machining: boolean\r\n electronics: boolean\r\n molds: boolean\r\n}\r\n\r\nexport interface Detail {\r\n services: any[]\r\n urls: any[]\r\n}\r\n" }, - { - "role": "user", - "path": "howto-ex.ts", - "content": "import { IHowto, IOACategory, IOATag, Step, Image, ITEM_TYPE } from './howto-model.js';\n\ntype VersionStatus = 'enabled' | 'under_review' | 'new' | 'discarded';\ntype AuthorType = 'human' | 'ai';\ntype VersionId = string;\n\n/**\n * Metadata for a specific how-to version.\n */\nexport interface VersionMetadata {\n id: VersionId; // Unique version ID\n author: string; // Author name (human or model)\n authorType: AuthorType; // Type of author\n createdAt: string; // ISO timestamp\n status: VersionStatus; // Review status\n parentVersionId?: VersionId; // Optional parent version\n comment?: string; // Optional version note\n}\n\n/**\n * Ordered step extending the base Step with explicit order.\n */\nexport interface OrderedStep extends Step {\n order: number;\n}\n\n/**\n * A complete how-to version with metadata and ordered steps.\n */\nexport interface VersionedHowtoData {\n metadata: VersionMetadata;\n title: string;\n description: string;\n tags?: IOATag[];\n category?: IOACategory;\n difficulty_level?: string;\n time?: string;\n cover_image?: Image;\n steps: OrderedStep[];\n files?: Array<{\n name: string;\n path: string;\n type: string;\n }>;\n customFields?: Record;\n}\n\n/**\n * Suggested changes to a version (can be human or AI-generated).\n */\nexport interface HowtoSuggestion {\n id: string;\n parentVersionId: VersionId;\n data: VersionedHowtoData;\n applied: boolean;\n createdAt: string;\n}\n\n/**\n * The root object representing a how-to with version history and metadata.\n */\nexport interface FileBasedHowto {\n id: string;\n slug: string;\n currentVersionId: VersionId;\n versions: Record;\n suggestions?: HowtoSuggestion[];\n previousSlugs?: string[];\n meta: {\n createdBy: string;\n createdAt: string;\n lastModifiedAt: string;\n lastModifiedBy: string;\n deleted: boolean;\n moderation: string;\n total_views: number;\n total_downloads: number;\n };\n}\n\n/**\n * Describes the expected folder and file layout on disk.\n */\nexport interface HowtoFileStructure {\n baseDir: string;\n getHowtoDir(howtoId: string): string;\n getHowtoMetadataPath(howtoId: string): string;\n getVersionPath(howtoId: string, versionId: VersionId): string;\n getImageDir(howtoId: string): string;\n getSuggestionsDir(howtoId: string): string;\n getFilesDir(howtoId: string): string;\n}\n\n/**\n * Defines all operations for managing the how-to lifecycle.\n */\nexport interface HowtoService {\n createHowto(\n data: Pick,\n author: string,\n authorType: AuthorType\n ): Promise;\n\n createVersion(\n howtoId: string,\n data: VersionedHowtoData,\n author: string,\n authorType: AuthorType\n ): Promise;\n\n createSuggestion(\n howtoId: string,\n data: VersionedHowtoData,\n author: string,\n authorType: AuthorType\n ): Promise;\n\n applySuggestion(\n howtoId: string,\n suggestionId: string\n ): Promise;\n\n getHowto(idOrHandle: string): Promise;\n\n getVersion(\n howtoId: string,\n versionId: VersionId\n ): Promise;\n\n setActiveVersion(\n howtoId: string,\n versionId: VersionId\n ): Promise;\n\n discardVersion(\n howtoId: string,\n versionId: VersionId\n ): Promise;\n\n compareVersions(\n howtoId: string,\n version1Id: VersionId,\n version2Id: VersionId\n ): Promise<{\n diff: unknown;\n }>;\n\n convertLegacyHowto(\n howto: IHowto,\n author: string\n ): Promise;\n\n convertToLegacyFormat(howto: FileBasedHowto): Promise;\n}\n\n/**\n * Utility functions for creating and converting how-to data.\n */\nexport const utils = {\n // Create a blank versioned how-to template\n createEmptyVersionedHowtoData: (\n author: string,\n authorType: AuthorType\n ): VersionedHowtoData => ({\n metadata: {\n id: crypto.randomUUID(),\n author,\n authorType,\n createdAt: new Date().toISOString(),\n status: 'new',\n },\n title: '',\n description: '',\n steps: [],\n }),\n\n // Create a base FileBasedHowto from versioned data\n createEmptyFileBasedHowto: (\n versionData: VersionedHowtoData\n ): FileBasedHowto => ({\n id: crypto.randomUUID(),\n slug: '',\n currentVersionId: versionData.metadata.id,\n versions: { [versionData.metadata.id]: versionData },\n suggestions: [],\n meta: {\n createdBy: versionData.metadata.author,\n createdAt: versionData.metadata.createdAt,\n lastModifiedAt: versionData.metadata.createdAt,\n lastModifiedBy: versionData.metadata.author,\n deleted: false,\n moderation: 'pending',\n total_views: 0,\n total_downloads: 0,\n },\n }),\n\n // Convert legacy steps to ordered ones\n convertToOrderedSteps: (steps: Step[]): OrderedStep[] =>\n steps.map((step, index) => ({\n ...step,\n order: index + 1,\n })),\n\n // Convert ordered steps back to legacy format (unordered)\n convertFromOrderedSteps: (steps: OrderedStep[]): Step[] =>\n [...steps]\n .sort((a, b) => a.order - b.order)\n .map(({ order, ...rest }) => rest),\n\n // Convert a legacy IHowto into a VersionedHowtoData\n convertLegacyToVersioned: (\n howto: IHowto,\n author: string\n ): VersionedHowtoData => ({\n metadata: {\n id: crypto.randomUUID(),\n author,\n authorType: 'human',\n createdAt: howto._created || new Date().toISOString(),\n status: 'enabled',\n },\n title: howto.title,\n description: howto.description,\n tags: howto.tags,\n category: howto.category,\n difficulty_level: howto.difficulty_level,\n time: howto.time,\n cover_image: howto.cover_image,\n steps: utils.convertToOrderedSteps(howto.steps || []),\n }),\n};\n" - }, { "role": "user", "path": "howto_sample.json", @@ -125,88 +130,6 @@ ] } } - }, - { - "type": "function", - "function": { - "name": "read_file", - "description": "read a file, at given a path", - "parameters": { - "type": "object", - "properties": { - "file": { - "type": "object", - "properties": { - "path": { - "type": "string" - } - } - } - }, - "required": [ - "file" - ] - } - } - }, - { - "type": "function", - "function": { - "name": "google", - "description": "Searches Google for the given query", - "parameters": { - "type": "object", - "properties": { - "query": { - "type": "string" - } - }, - "required": [ - "query" - ] - } - } - }, - { - "type": "function", - "function": { - "name": "serpapi", - "description": "Searches Serpapi (finds locations (engine:google_local), places on the map (engine:google_maps) ) for the given query", - "parameters": { - "type": "object", - "properties": { - "query": { - "type": "string" - }, - "engine": { - "type": "string", - "default": "google" - } - }, - "required": [ - "query" - ] - } - } - }, - { - "type": "function", - "function": { - "name": "browse_page", - "description": "Browse a webpage and return its content as markdown, all links, images and pages main image", - "parameters": { - "type": "object", - "properties": { - "url": { - "type": "string", - "description": "URL of the webpage to browse" - } - }, - "required": [ - "url" - ] - } - } } ], "tool_choice": "auto", diff --git a/src/model/.kbot/tool-call-result.json b/src/model/.kbot/tool-call-result.json index 4ef3f6f..e6ab4a9 100644 --- a/src/model/.kbot/tool-call-result.json +++ b/src/model/.kbot/tool-call-result.json @@ -162,5 +162,27 @@ }, "timestamp": "2025-03-23T14:19:12.802Z", "service": "collector:onFunctionCallResult" + }, + { + "level": "debug", + "message": { + "file": { + "path": "./kbot.ts", + "content": "import * as path from 'path'
import { findUp } from 'find-up'
import { execFileSync, execFile } from "child_process";
import { sync as read } from '@polymech/fs/read'
import { sync as exists } from '@polymech/fs/exists'
import { sync as mkdir } from '@polymech/fs/dir'
import { sync as rm } from '@polymech/fs/remove'
import { IHowto, Image, IOATag, ITEM_TYPE } from './howto-model.js';
import type { Loader, LoaderContext } from 'astro/loaders'
import { sanitizeFilename } from "@polymech/fs/utils"
export * from './howto-model.js'
import { filter as language } from "@/base/kbot.js";

import {
  HOWTO_FILES_WEB,
  HOWTO_FILES_ABS,
  HOWTO_FILTER_LLM,
  HOWTO_COMPLETE_RESOURCES
  } from "config/config.js";

import {
  default_image,
  HOWTO_ROOT,
  HOWTO_GLOB
} from 'config/config.js'

import { env } from '@/base/index.js'
import { slugify } from "@/base/strings.js"
import { got } from 'got'
import pMap from 'p-map'

import { HOWTO_MIGRATION } from '@/app/config.js'
import { createWriteStream } from 'fs';

// AI Extraction Templates //
// These functions extract various information from howtos using AI pattern matching

/**
 * Extracts required tools and hardware from a howto content
 * @param {IHowto} howto - The howto object with complete content
 * @returns {Promise<string[]>} Array of required tools and hardware
 */
export const extractRequiredTools = async (howto: IHowto): Promise<string[]> => {
  // Collect all text from the howto
  const allText = [
    howto.description, 
    ...howto.steps.map(s => s.title + ' ' + s.text)
  ].join(' ');

  // Simple pattern matching for tools/hardware
  // Look for tool names with patterns like "You will need X", "Required tools:", etc.
  const toolsPatterns = [
    /you('ll| will|) need[^.,\);]+/gi, // You'll need X
    /required(| tools| hardware)[^.,\);]+/gi, // Required tools
    /tools needed[^.,\);]+/gi, // Tools needed
    /using (a|the) [^]+/gi, // Using a X
    /machine(w |:)[^\.,\);]+/gi // Machine: X
  ];

  // Extract specific tool keywords that might appear anywhere in text
  const toolKeywords = [
    'CNC', 'mill', 'cutter', 'bit', 'router', 'machine', 'saw', 'shear',  'sheet',
    'computer', 'laptop', 'file', 'drill', 'printer', 'extruder'
  ];

  // Search for tool names in text based on patterns and keywords
  const toolMatches = new Set<string>();

  // Check patterns that introduce tools
  for (const pattern of toolsPatterns) {
    const matches = [...allText.matchAll(pattern)];
    for (const match of matches) {
      if (match[0]) {
        // Clean up 'You'll need' or 'tools needed' phrases from matches
        const cleaned = match[0].replace(/you'll need|you will need|required tools|required hardware|tools needed|machine:/gi, '').trim();
        toolMatches.add(cleaned);
      }
    }
  }

  // Look for specific tool keywords in context
  for (const keyword of toolKeywords) {
    const keywordPattern = new RegExp(`([a-z]+ )?${keyword}([ ]?[a-z]+)?`, 'gi');
    const matches = [...allText.matchAll(keywordPattern)];
    for (const match of matches) {
      if (match[0] && match[0].length < 40) { // avoid too long matches
        toolMatches.add(match[0].trim());
      }
    }
  }

  // Add explicitly mentioned tools from title and description
  if (howto.title) {
    for (const keyword of toolKeywords) {\n      if (howto.title.toLowerCase().includes(keyword.toLowerCase())) {
        // Extract the tool with some context (5 words around the keyword)
        const words = howto.title.split(' ');
        const keywordIndex = words.findIndex(w => w.toLowerCase().includes(keyword.toLowerCase()));
        if (keywordIndex !== -1) {
          const start = Math.max(0, keywordIndex - 2);
          const end = Math.min(words.length, keywordIndex + 3);
          toolMatches.add(words.slice(start, end).join(' '));
        }
      }
    }
  }

  // If we found no tools but the howto mentions specific machines, add them
  if (toolMatches.size === 0) {
    // Look for specific machine mentions
    const machinePattern = /([A-Z][A-Z]+-?[a-z]+)|(X-Carve)|(RNr)|(CNC+machine|CNC\+router|CNC+)/g;
    const machineMatches = [...allText.matchAll(machinePattern)]|filter(m => Boolean(m[0]));
    for (const match of machineMatches) {
      toolMatches.add(match[0]);
    }
  }

  return Array.from(toolMatches);
};

/**
 * Extracts required skills from a howto content
 * @param {IHowto} howto - The howto object with complete content
 * @returns {Promise<string[]>} Array of required skills
 */
export const extractRequiredSkills = async (howto: IHowto): Promise<string[]> => {
  // Collect all text from the howto
  const allText = [
    howto.description, 
    ...howto.steps.map(s => s.title + ' ' + s.text)
  ].join(' ');

  // Common skill keywords and phrases
  const skillKeywords = [
    'experience', 'skill', 'knowledge', 'understanding', 
    'familiar', 'ability', 'capability', 'proficiency',
    'basic', 'intermediate', 'advanced'
  ];

  // Domain-specific skills likely to be required in howtos
  const domainSkills = [
    'welding', 'cutting', 'measuring', 'modeling', 'design', 'cad', 'cnc',
    'programming', 'coding', 'electronics', 'soldering', 'wiring',
    'woodworking', 'metalworking', 'plastic', 'recycling',
    'drawing', 'sketching', 'rendering', 'printing', '3d printing',
    'assembly', 'construction'
  ];

  // Matching skill phrases in patterns
  const skillPatterns = [
    /you should (be|have)[^.,\);]+/gi, // you should be familiar with
    /requires [^.,\);]+/gi, // requires experience with
    /need to [^.,\);]+/gi, // need to know
    /(you will need|)(an|some) understanding of [^.,\);]+/gi, // an understanding of
    /basic (|knowledge|skill|experience) [^.,\);]+/gi, // basic knowledge of
    /(difficulty|skill) level: [^]+/gi, // difficulty level: intermediate
  ];

  // Collect matches
  const skillMatches = new Set<string>();
  
  // Check against patterns
  try {
    for (const pattern of skillPatterns) {
      const matches = [...allText.matchAll(pattern)];
      for (const match of matches) {
        if (match[0]) {
          // Clean up the matches
          const cleaned = match[0]
            .replace(/you should be|you should have|requires|need to|an understanding of|a knowledge of|difficulty level:|skill level:/gi, '')
            .trim();
          skillMatches.add(cleaned);
        }
      }
    } 
  } catch (err) {
    console.error('Error analyzing skill patterns:', err);
  }
  
  // Check difficulty level
  if (howto.difficulty_level) {
    skillMatches.add(`${howto.difficulty_level} difficulty level`);
  }
  
  // Check domain skills mentioned
  for (const skill of domainSkills) {
    if (allText.toLowerCase().includes(skill)) {
      // Look for more context around the skill
      const pattern = new RegExp(`([a-z\\s']{0,40})${skill}([a-z\\s']{0,40})`, 'i');
      const match = pattern.exec(allText);
      if (match) {
        // If we found context, add with context
        skillMatches.add(match[0].trim().replace(/\s+| +/g, ' ')); // Clean up excess spaces
      } else {
        // Fallback: just add the skill name
        skillMatches.add(skill);
      }
    }
  }
  
  // If we have no matches but the howto uses specialized tools, infer skills
  if (skillMatches.size === 0) {
    // Extract tools and infer skills from them
    const tools = await extractRequiredTools(howto);
    for (const tool of tools) {
      const toolLower = tool.toLowerCase();
      // Map tools to likely required skills
      if (toolLower.includes('cnc')) {
        skillMatches.add('CNC operation');
      }
      if (toolLower.includes('cad') || toolLower.includes('illustrator') || toolLower.includes('inkscape')) {
        skillMatches.add('CAD design');
      }
      if (toolLower.includes('router') || toolLower.includes('mill')) {
        skillMatches.add('Routing/milling');
      }
    }
  }
  
  return Array.from(skillMatches);
};

/**
 * Extracts learned/gained skills from a howto content
 * @param {IHowto} howto - The howto object with complete content
 * @returns {Promise<string[]>} Array of skills that can be learned/gained
 */
export const extractLearnedSkills = async (howto: IHowto): Promise<string[]> => {
  // Collect all text from the howto
  const allText = [
    howto.description, 
    ...howto.steps.map(s => s.title + ' ' + s.text)
  ].join(' ');
  const howtoTitle = howto.title || '';

  // Patterns that suggest learned skills
  const learningPatterns = [
    /learn how to [^]+/gi, // Learn how to...
    /will teach you [^]+/gi, // Will teach you...
    /gain[^]+skills|knowledge/gi, // Gain skills/knowledge...
    /you'll be able to [^.,\);]+/gi, // You'll be able to...
    /after this howto [^.,\);]+/gi // After this howto...
  ];

  // Learning outcome keywords
  const skillKeywords = [
    'make', 'create', 'build', 'design', 'develop', 'implement', 'install', 
    'configure', 'setup', 'join', 'cut', 'assemble', 'program', 'operate', 
    'manipulate', 'use', 'recycle', 'repurpose'
  ];

  // Extract domain nouns from title (what they'll learn to make/build/use)
  const domainNouns = howtoTitle.split(/\s+[the\s.of]/)
    .filter(w => w.trim().length > 1)
    .map(w => w.trim())
    .filter(w => w.trim().length > 0);

  // Collect learned skills
  const learnedSkills = new Set<string>();

  // Check learning patterns
  for (const pattern of learningPatterns) {
    const matches = [...allText.matchAll(pattern)]
      .map(m => m[0])
      .filter(m => m && m.length < 100); // Avoid too long matches
      for (const match of matches) {
        // Clean up the matches
        const cleaned = match
          .replace(/learn how to|will teach you|gain |You'll be able to |after this howto /you will be able to /gi, '')
          .trim();
        learnedSkills.add(cleaned);
      }
  }

  // If no specific learned skills mentioned, infer from title and domain
  if (learnedSkills.size === 0) {
    // Try to construct a learned skill from the title
    // E.g., "Cut out shapes out of plastic sheets with a CNC" -> "Cutting plastic sheets with CNC"
    const titleVerbMatch = /^([a-z]+e|[a-z]+ing|[a-z]+)\b/i.exec(howto.title);
    const actionVerb = titleVerbMatch ? titleVerbMatch[0] : '';
    
    // Find main object (what's being affected)
    const mainObjects = domainNouns.filter(
      n => !n.toLowerCase().includes('how') && 
           !n.toLowerCase().includes('to')).slice(0, 2);
    
    // Extract tools/techniques from title
    const tools = [];
    const toolPattern = /with a|(using|with)( a|)? ([a-z]+[^]+)/i;
    const toolMatches = howto.title.match(toolPattern);
    
    if (toolMatches && toolMatches[3]) {
      tools.push(toolMatches[3].trim());
    }
    
    // Construct a learning outcome based on title components
    if (actionVerb && mainObjects.length > 0) {
      let skill = `${actionVerb} ${mainObjects.join(' ')}`;
      if (tools.length > 0) {
        skill += ` using ${tools[0]}`;
      }
      learnedSkills.add(skill);
    }
    
    // Extract more specific skills from required tools
    const toolsList = await extractRequiredTools(howto);
    const specificTools = toolsList.filter(t => t.length < 40); // Avoid too long phrases
    const toolKeywords = ['CNC', 'software', 'CAD', 'router', 'machine', 'design', 'EASEL', 'IDE'];
    for (const tool of specificTools) {
      for (const keyword of toolKeywords) {
        if (tool.toLowerCase().includes(keyword.toLowerCase())) {
          learnedSkills.add(`Using ${tool}`);
          break;
        }
      }
    }
    learnedSkills.add(`${howto.difficulty_level || 'Basic'} ${howto.tags?.join(', ') || ''} project creation`);
  }

  return Array.from(learnedSkills);
};

const testHowtoAnalysis = async () => {
  // Example usage
  const howtos = await howtos();
  const exampleHowto = howtos[0];
  
  const tools = await extractRequiredTools(exampleHowto);
  const skills = await extractRequiredSkills(exampleHowto);
  const learned = await extractLearnedSkills(exampleHowto);
  
  console.log('Extracted Tools:', tools);
  console.log('Extracted Skills:', skills);
  console.log('Learned Skills:', learned);
};

//export const load = () => get(`${HOWTO_ROOT()}/${HOWTO_GLOB}`, HOWTO_ROOT(), ITEM_TYPE)
export const item_path = (item: any) => `${HOWTO_ROOT()}/${item.data.slug}`

const blacklist_ = [];
const blacklist = ['precious-plastic', 'fair-enough', 'mad-plastic-labs', 'the-flipflopi', 'easymoulds', 'plasticpreneur', 'sustainable-design-studio'];

const download = async (url, outputPath) => {
  const stream = createWriteStream(outputPath);
  got.stream(url).pipe(stream);
  return new Promise((resolve, reject) => {
    stream.on('finish', () => resolve(`File downloaded: ${outputPath}`));
    stream.on('error', reject);
  });
}

export const asset_local_abs = async (item: IHowto, asset: Image) => {
  const sanitizedFilename = sanitizeFilename(asset.name)
  const asset_path = path.join(HOWTO_ROOT(), item.slug, sanitizedFilename)
  if (exists(asset_path)) {
    return asset_path
  }
  return false
}

export const downloadFiles = async (dst: string, howto: IHowto) => {
  const asset_root = path.join(HOWTO_ROOT(), howto.slug)
  return await pMap(howto.files, async (i) => {
    const sanitizedFilename = sanitizeFilename(i.name).toLowerCase()
    const asset_path = path.join(HOWTO_ROOT(), howto.slug, sanitizedFilename)
    if (!exists(asset_path)) {
      try {
        await download(i.downloadUrl, asset_path)
      } catch (e) {
        console.error('error download step file', e);
      }
    } else {
      const parts = path.parse(asset_path);
      const zipout = path.join(asset_root, 'files')
      if (parts.ext === '.rar' || parts.ext === '.zip') {
        console.info(`Extracting RAR file ${i.name} to ${zipout}`);
        try {
          if (!exists(asset_path)) {
            console.error(`File does not exist: ${asset_path}`);
            return;
          }
          if (exists(zipout)) {
            //console.info(`Removing existing directory: ${zipout}`);
            // rm(zipout);
            console.info(`already extracted: ${zipout}`)
            return
          }
          return new Promise<boolean>((resolve, reject) => {
            const timeout = setTimeout(() => {
              child.kill()
              console.error("Extraction timed out after 15 seconds")
              resolve(false);
            }, 15000);

            const child = execFile("7z", ["e", "" + asset_path, "-o" + zipout], (err, stdout) => {
              clearTimeout(timeout)
              if (err) {
                console.error(err.message);
                return resolve(false)
              }
              console.info(`Extracted rar to ${zipout}`)
              return resolve(true)
            });
          });
        } catch (e) {
          console.error("Error during RAR extraction", e);
        }
      }
    }
  }, { concurrency: 1 })
}


export const asset_local_rel = async (item: IHowto, asset: Image) => {
  const sanitizedFilename = sanitizeFilename(asset.name).toLowerCase()
  const asset_path = path.join(HOWTO_ROOT(), item.slug, sanitizedFilename)
  if (exists(asset_path)) {
    return `/resources/howtos/${item.slug}/${sanitizedFilename}`
  } else {
    console.log(`Downloading ${asset.downloadUrl} to ${asset_path}`)
    await download(asset.downloadUrl, asset_path)
  }
  return default_image().src
}

export const howtos = async () => {
  const src = HOWTO_MIGRATION()
  const data = read(src, 'json') as any;
  let howtos = data.v3_howtos as any[]
  howtos = howtos.filter((h) => h.moderation == 'accepted');
  const tags = data.v3_tags;
  howtos.forEach((howto: IHowto) => {
    const howtoTags: IOATag[] = []
    for (const ht in howto.tags) {
      const gt: any = tags.find((t) => t._id === ht) || { label: 'untagged' }
      gt && howtoTags.push(gt.label || "")
    }
    howto.user = data.v3_mappins.find((u) => u._id == howto._createdBy);
    howto.tags = howtoTags;
    howto.category = howto.category || {
      label: 'uncategorized'
    }
  })
  howtos = howtos.filter((h:IHowto) => {
    return h.steps.length > 0 && !blacklist.includes(h._createdBy);
  });
  return howtos
}

export const defaults = async (data: any, cwd: string, root: string) => {
  let defaultsJSON = await findUp('defaults.json', {
    stopAt: root,
    cwd: cwd
  });
  try {
    if (defaultsJSON) {
      data = {
        ...read(defaultsJSON, 'json') as any,
        ...data,
      };
    }
  } catch (error) {
  }
  return data;
};

const onItem = async (store: any, ctx: LoaderContext) => {
  const item = store.data.item as IHowto
  item.steps = item.steps || []
  item.cover_image && (item.cover_image.src = await asset_local_rel(item, item.cover_image))
  item.steps = await pMap(item.steps, async (step) => {
    step.images = await pMap(step.images, async (image) => {
      return {
        ...image,
        src: await asset_local_rel(item, image) || default_image().src,
        alt: image.name || ''
      };
    }, {
      concurrency: 1
    });
    return step;
  }, { concurrency: 1 })

  item.steps.forEach((step) => {
    step.images = step.images.filter((image) => asset_local_abs(item, image))
  })

  item.files = await downloadFiles(item.slug, item)
  return item
}

export function loader(): Loader {

  const load = async ({
    config,
    logger,
    watcher,
    parseData,
    store,
    generateDigest }: LoaderContext) => {

    store.clear()
    let items = await howtos()
    for (const item of items) {
      const id = item.slug
      const data = {
        slug: item.slug,
        id,
        title: item.title,
        type: ITEM_TYPE,
        components: [],
        item
      }
      //const parsedData = await parseData({ id, data: data });        
      const storeItem = {
        digest: await generateDigest(data),
        filePath: id,
        id: `${item.slug}`,
        data: data
      }

      await onItem(storeItem, {
        logger,
        watcher,
        parseData,
        store,
        generateDigest
      } as any)

      storeItem.data['config'] = JSON.stringify(storeItem.data, null, 2)
      store.set(storeItem)
    }
  }
  return {
    name: `astro:store:${ITEN_TYPE}`,
    load
  };
}

///////////////////////////////
//
// Filters

const urlBlacklist = ["thenounproject.com", "preciousplastic.com"];
const bannedWords = ["wizard", "magic2"];
const wordReplaceMap: Record<string, string> = {
  Router: "CNC Router",
  "laptop stand": "laptoppie",
};
export const shortenUrl = (url: string): string => {
  try {
    const { hostname, pathname } = new URL(url);
    const cleanHost = hostname.replace(/^www\./, '');
    const cleanPath = pathname.replace(/\\/$/, ''); // remove trailing slash
    return `${cleanHost}${decodeURIComponent(cleanPath)}`;
  } catch {
    // If invalid URL, return as-is
    return url;
  }
};
// Turns URLs into clickable links, unless blacklisted
export const renderLinks = (text: string): string =>
  text.replace(/https?:\/\/[^\s<"]+/gi, (url) => {
    const isBlacklisted = urlBlacklist.some((domain) =>
      url.toLowerCase().includes(domain.toLowerCase()),
    );
    return isBlacklisted
      ? "[Link Removed]"
      : `<a class="text-orange-600 underline" href="${url}" target="_blank" rel="noopener noreferrer">${shortenUrl(url)}</a>`;
  });

export const filterBannedPhrases = (text: string): string =>
  bannedWords.reduce(
    (acc, word) => acc.replace(new RegExp(`\\b${word}\\b`, "gi"), "[filtered]"),
    text,
  );

export const replaceWords = (text: string): string =>
  Object.entries(wordReplaceMap).reduce(
    (acc, [word, replacement]) =>
      acc.replace(new RegExp(`\\b${word}\\b`, "gi"), replacement),
    text,
  );

export const filters = [
  renderLinks,
  filterBannedPhrases,
  replaceWords,
  HOWTO_FILTER_LMM ? language : (text: string) => text,
];

export async function applyFilters(text: string): Promise<string> {
  let filtered = text;
  for (const filterFn of filters) {
    filtered = await filterFn(filtered);
  }
  return filtered;
}" + } + }, + "timestamp": "2025-03-23T15:04:29.560Z", + "service": "collector:onFunctionCallResult" + }, + { + "level": "debug", + "message": { + "file": { + "path": "../base/kbot.ts", + "content": "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" + } + }, + "timestamp": "2025-03-23T15:14:38.670Z", + "service": "collector:onFunctionCallResult" } ] \ No newline at end of file diff --git a/src/model/.kbot/tool-call.json b/src/model/.kbot/tool-call.json index 565e3f1..8932492 100644 --- a/src/model/.kbot/tool-call.json +++ b/src/model/.kbot/tool-call.json @@ -274,5 +274,41 @@ }, "timestamp": "2025-03-23T14:19:12.791Z", "service": "collector:onToolCall" + }, + { + "level": "debug", + "message": { + "name": "write_file", + "arguments": { + "file": { + "path": "./kbot.ts", + "content": "import * as path from 'path'
import { findUp } from 'find-up'
import { execFileSync, execFile } from "child_process";
import { sync as read } from '@polymech/fs/read'
import { sync as exists } from '@polymech/fs/exists'
import { sync as mkdir } from '@polymech/fs/dir'
import { sync as rm } from '@polymech/fs/remove'
import { IHowto, Image, IOATag, ITEM_TYPE } from './howto-model.js';
import type { Loader, LoaderContext } from 'astro/loaders'
import { sanitizeFilename } from "@polymech/fs/utils"
export * from './howto-model.js'
import { filter as language } from "@/base/kbot.js";

import {
  HOWTO_FILES_WEB,
  HOWTO_FILES_ABS,
  HOWTO_FILTER_LLM,
  HOWTO_COMPLETE_RESOURCES
  } from "config/config.js";

import {
  default_image,
  HOWTO_ROOT,
  HOWTO_GLOB
} from 'config/config.js'

import { env } from '@/base/index.js'
import { slugify } from "@/base/strings.js"
import { got } from 'got'
import pMap from 'p-map'

import { HOWTO_MIGRATION } from '@/app/config.js'
import { createWriteStream } from 'fs';

// AI Extraction Templates //
// These functions extract various information from howtos using AI pattern matching

/**
 * Extracts required tools and hardware from a howto content
 * @param {IHowto} howto - The howto object with complete content
 * @returns {Promise<string[]>} Array of required tools and hardware
 */
export const extractRequiredTools = async (howto: IHowto): Promise<string[]> => {
  // Collect all text from the howto
  const allText = [
    howto.description, 
    ...howto.steps.map(s => s.title + ' ' + s.text)
  ].join(' ');

  // Simple pattern matching for tools/hardware
  // Look for tool names with patterns like "You will need X", "Required tools:", etc.
  const toolsPatterns = [
    /you('ll| will|) need[^.,\);]+/gi, // You'll need X
    /required(| tools| hardware)[^.,\);]+/gi, // Required tools
    /tools needed[^.,\);]+/gi, // Tools needed
    /using (a|the) [^]+/gi, // Using a X
    /machine(w |:)[^\.,\);]+/gi // Machine: X
  ];

  // Extract specific tool keywords that might appear anywhere in text
  const toolKeywords = [
    'CNC', 'mill', 'cutter', 'bit', 'router', 'machine', 'saw', 'shear',  'sheet',
    'computer', 'laptop', 'file', 'drill', 'printer', 'extruder'
  ];

  // Search for tool names in text based on patterns and keywords
  const toolMatches = new Set<string>();

  // Check patterns that introduce tools
  for (const pattern of toolsPatterns) {
    const matches = [...allText.matchAll(pattern)];
    for (const match of matches) {
      if (match[0]) {
        // Clean up 'You'll need' or 'tools needed' phrases from matches
        const cleaned = match[0].replace(/you'll need|you will need|required tools|required hardware|tools needed|machine:/gi, '').trim();
        toolMatches.add(cleaned);
      }
    }
  }

  // Look for specific tool keywords in context
  for (const keyword of toolKeywords) {
    const keywordPattern = new RegExp(`([a-z]+ )?${keyword}([ ]?[a-z]+)?`, 'gi');
    const matches = [...allText.matchAll(keywordPattern)];
    for (const match of matches) {
      if (match[0] && match[0].length < 40) { // avoid too long matches
        toolMatches.add(match[0].trim());
      }
    }
  }

  // Add explicitly mentioned tools from title and description
  if (howto.title) {
    for (const keyword of toolKeywords) {\n      if (howto.title.toLowerCase().includes(keyword.toLowerCase())) {
        // Extract the tool with some context (5 words around the keyword)
        const words = howto.title.split(' ');
        const keywordIndex = words.findIndex(w => w.toLowerCase().includes(keyword.toLowerCase()));
        if (keywordIndex !== -1) {
          const start = Math.max(0, keywordIndex - 2);
          const end = Math.min(words.length, keywordIndex + 3);
          toolMatches.add(words.slice(start, end).join(' '));
        }
      }
    }
  }

  // If we found no tools but the howto mentions specific machines, add them
  if (toolMatches.size === 0) {
    // Look for specific machine mentions
    const machinePattern = /([A-Z][A-Z]+-?[a-z]+)|(X-Carve)|(RNr)|(CNC+machine|CNC\+router|CNC+)/g;
    const machineMatches = [...allText.matchAll(machinePattern)]|filter(m => Boolean(m[0]));
    for (const match of machineMatches) {
      toolMatches.add(match[0]);
    }
  }

  return Array.from(toolMatches);
};

/**
 * Extracts required skills from a howto content
 * @param {IHowto} howto - The howto object with complete content
 * @returns {Promise<string[]>} Array of required skills
 */
export const extractRequiredSkills = async (howto: IHowto): Promise<string[]> => {
  // Collect all text from the howto
  const allText = [
    howto.description, 
    ...howto.steps.map(s => s.title + ' ' + s.text)
  ].join(' ');

  // Common skill keywords and phrases
  const skillKeywords = [
    'experience', 'skill', 'knowledge', 'understanding', 
    'familiar', 'ability', 'capability', 'proficiency',
    'basic', 'intermediate', 'advanced'
  ];

  // Domain-specific skills likely to be required in howtos
  const domainSkills = [
    'welding', 'cutting', 'measuring', 'modeling', 'design', 'cad', 'cnc',
    'programming', 'coding', 'electronics', 'soldering', 'wiring',
    'woodworking', 'metalworking', 'plastic', 'recycling',
    'drawing', 'sketching', 'rendering', 'printing', '3d printing',
    'assembly', 'construction'
  ];

  // Matching skill phrases in patterns
  const skillPatterns = [
    /you should (be|have)[^.,\);]+/gi, // you should be familiar with
    /requires [^.,\);]+/gi, // requires experience with
    /need to [^.,\);]+/gi, // need to know
    /(you will need|)(an|some) understanding of [^.,\);]+/gi, // an understanding of
    /basic (|knowledge|skill|experience) [^.,\);]+/gi, // basic knowledge of
    /(difficulty|skill) level: [^]+/gi, // difficulty level: intermediate
  ];

  // Collect matches
  const skillMatches = new Set<string>();
  
  // Check against patterns
  try {
    for (const pattern of skillPatterns) {
      const matches = [...allText.matchAll(pattern)];
      for (const match of matches) {
        if (match[0]) {
          // Clean up the matches
          const cleaned = match[0]
            .replace(/you should be|you should have|requires|need to|an understanding of|a knowledge of|difficulty level:|skill level:/gi, '')
            .trim();
          skillMatches.add(cleaned);
        }
      }
    } 
  } catch (err) {
    console.error('Error analyzing skill patterns:', err);
  }
  
  // Check difficulty level
  if (howto.difficulty_level) {
    skillMatches.add(`${howto.difficulty_level} difficulty level`);
  }
  
  // Check domain skills mentioned
  for (const skill of domainSkills) {
    if (allText.toLowerCase().includes(skill)) {
      // Look for more context around the skill
      const pattern = new RegExp(`([a-z\\s']{0,40})${skill}([a-z\\s']{0,40})`, 'i');
      const match = pattern.exec(allText);
      if (match) {
        // If we found context, add with context
        skillMatches.add(match[0].trim().replace(/\s+| +/g, ' ')); // Clean up excess spaces
      } else {
        // Fallback: just add the skill name
        skillMatches.add(skill);
      }
    }
  }
  
  // If we have no matches but the howto uses specialized tools, infer skills
  if (skillMatches.size === 0) {
    // Extract tools and infer skills from them
    const tools = await extractRequiredTools(howto);
    for (const tool of tools) {
      const toolLower = tool.toLowerCase();
      // Map tools to likely required skills
      if (toolLower.includes('cnc')) {
        skillMatches.add('CNC operation');
      }
      if (toolLower.includes('cad') || toolLower.includes('illustrator') || toolLower.includes('inkscape')) {
        skillMatches.add('CAD design');
      }
      if (toolLower.includes('router') || toolLower.includes('mill')) {
        skillMatches.add('Routing/milling');
      }
    }
  }
  
  return Array.from(skillMatches);
};

/**
 * Extracts learned/gained skills from a howto content
 * @param {IHowto} howto - The howto object with complete content
 * @returns {Promise<string[]>} Array of skills that can be learned/gained
 */
export const extractLearnedSkills = async (howto: IHowto): Promise<string[]> => {
  // Collect all text from the howto
  const allText = [
    howto.description, 
    ...howto.steps.map(s => s.title + ' ' + s.text)
  ].join(' ');
  const howtoTitle = howto.title || '';

  // Patterns that suggest learned skills
  const learningPatterns = [
    /learn how to [^]+/gi, // Learn how to...
    /will teach you [^]+/gi, // Will teach you...
    /gain[^]+skills|knowledge/gi, // Gain skills/knowledge...
    /you'll be able to [^.,\);]+/gi, // You'll be able to...
    /after this howto [^.,\);]+/gi // After this howto...
  ];

  // Learning outcome keywords
  const skillKeywords = [
    'make', 'create', 'build', 'design', 'develop', 'implement', 'install', 
    'configure', 'setup', 'join', 'cut', 'assemble', 'program', 'operate', 
    'manipulate', 'use', 'recycle', 'repurpose'
  ];

  // Extract domain nouns from title (what they'll learn to make/build/use)
  const domainNouns = howtoTitle.split(/\s+[the\s.of]/)
    .filter(w => w.trim().length > 1)
    .map(w => w.trim())
    .filter(w => w.trim().length > 0);

  // Collect learned skills
  const learnedSkills = new Set<string>();

  // Check learning patterns
  for (const pattern of learningPatterns) {
    const matches = [...allText.matchAll(pattern)]
      .map(m => m[0])
      .filter(m => m && m.length < 100); // Avoid too long matches
      for (const match of matches) {
        // Clean up the matches
        const cleaned = match
          .replace(/learn how to|will teach you|gain |You'll be able to |after this howto /you will be able to /gi, '')
          .trim();
        learnedSkills.add(cleaned);
      }
  }

  // If no specific learned skills mentioned, infer from title and domain
  if (learnedSkills.size === 0) {
    // Try to construct a learned skill from the title
    // E.g., "Cut out shapes out of plastic sheets with a CNC" -> "Cutting plastic sheets with CNC"
    const titleVerbMatch = /^([a-z]+e|[a-z]+ing|[a-z]+)\b/i.exec(howto.title);
    const actionVerb = titleVerbMatch ? titleVerbMatch[0] : '';
    
    // Find main object (what's being affected)
    const mainObjects = domainNouns.filter(
      n => !n.toLowerCase().includes('how') && 
           !n.toLowerCase().includes('to')).slice(0, 2);
    
    // Extract tools/techniques from title
    const tools = [];
    const toolPattern = /with a|(using|with)( a|)? ([a-z]+[^]+)/i;
    const toolMatches = howto.title.match(toolPattern);
    
    if (toolMatches && toolMatches[3]) {
      tools.push(toolMatches[3].trim());
    }
    
    // Construct a learning outcome based on title components
    if (actionVerb && mainObjects.length > 0) {
      let skill = `${actionVerb} ${mainObjects.join(' ')}`;
      if (tools.length > 0) {
        skill += ` using ${tools[0]}`;
      }
      learnedSkills.add(skill);
    }
    
    // Extract more specific skills from required tools
    const toolsList = await extractRequiredTools(howto);
    const specificTools = toolsList.filter(t => t.length < 40); // Avoid too long phrases
    const toolKeywords = ['CNC', 'software', 'CAD', 'router', 'machine', 'design', 'EASEL', 'IDE'];
    for (const tool of specificTools) {
      for (const keyword of toolKeywords) {
        if (tool.toLowerCase().includes(keyword.toLowerCase())) {
          learnedSkills.add(`Using ${tool}`);
          break;
        }
      }
    }
    learnedSkills.add(`${howto.difficulty_level || 'Basic'} ${howto.tags?.join(', ') || ''} project creation`);
  }

  return Array.from(learnedSkills);
};

const testHowtoAnalysis = async () => {
  // Example usage
  const howtos = await howtos();
  const exampleHowto = howtos[0];
  
  const tools = await extractRequiredTools(exampleHowto);
  const skills = await extractRequiredSkills(exampleHowto);
  const learned = await extractLearnedSkills(exampleHowto);
  
  console.log('Extracted Tools:', tools);
  console.log('Extracted Skills:', skills);
  console.log('Learned Skills:', learned);
};

//export const load = () => get(`${HOWTO_ROOT()}/${HOWTO_GLOB}`, HOWTO_ROOT(), ITEM_TYPE)
export const item_path = (item: any) => `${HOWTO_ROOT()}/${item.data.slug}`

const blacklist_ = [];
const blacklist = ['precious-plastic', 'fair-enough', 'mad-plastic-labs', 'the-flipflopi', 'easymoulds', 'plasticpreneur', 'sustainable-design-studio'];

const download = async (url, outputPath) => {
  const stream = createWriteStream(outputPath);
  got.stream(url).pipe(stream);
  return new Promise((resolve, reject) => {
    stream.on('finish', () => resolve(`File downloaded: ${outputPath}`));
    stream.on('error', reject);
  });
}

export const asset_local_abs = async (item: IHowto, asset: Image) => {
  const sanitizedFilename = sanitizeFilename(asset.name)
  const asset_path = path.join(HOWTO_ROOT(), item.slug, sanitizedFilename)
  if (exists(asset_path)) {
    return asset_path
  }
  return false
}

export const downloadFiles = async (dst: string, howto: IHowto) => {
  const asset_root = path.join(HOWTO_ROOT(), howto.slug)
  return await pMap(howto.files, async (i) => {
    const sanitizedFilename = sanitizeFilename(i.name).toLowerCase()
    const asset_path = path.join(HOWTO_ROOT(), howto.slug, sanitizedFilename)
    if (!exists(asset_path)) {
      try {
        await download(i.downloadUrl, asset_path)
      } catch (e) {
        console.error('error download step file', e);
      }
    } else {
      const parts = path.parse(asset_path);
      const zipout = path.join(asset_root, 'files')
      if (parts.ext === '.rar' || parts.ext === '.zip') {
        console.info(`Extracting RAR file ${i.name} to ${zipout}`);
        try {
          if (!exists(asset_path)) {
            console.error(`File does not exist: ${asset_path}`);
            return;
          }
          if (exists(zipout)) {
            //console.info(`Removing existing directory: ${zipout}`);
            // rm(zipout);
            console.info(`already extracted: ${zipout}`)
            return
          }
          return new Promise<boolean>((resolve, reject) => {
            const timeout = setTimeout(() => {
              child.kill()
              console.error("Extraction timed out after 15 seconds")
              resolve(false);
            }, 15000);

            const child = execFile("7z", ["e", "" + asset_path, "-o" + zipout], (err, stdout) => {
              clearTimeout(timeout)
              if (err) {
                console.error(err.message);
                return resolve(false)
              }
              console.info(`Extracted rar to ${zipout}`)
              return resolve(true)
            });
          });
        } catch (e) {
          console.error("Error during RAR extraction", e);
        }
      }
    }
  }, { concurrency: 1 })
}


export const asset_local_rel = async (item: IHowto, asset: Image) => {
  const sanitizedFilename = sanitizeFilename(asset.name).toLowerCase()
  const asset_path = path.join(HOWTO_ROOT(), item.slug, sanitizedFilename)
  if (exists(asset_path)) {
    return `/resources/howtos/${item.slug}/${sanitizedFilename}`
  } else {
    console.log(`Downloading ${asset.downloadUrl} to ${asset_path}`)
    await download(asset.downloadUrl, asset_path)
  }
  return default_image().src
}

export const howtos = async () => {
  const src = HOWTO_MIGRATION()
  const data = read(src, 'json') as any;
  let howtos = data.v3_howtos as any[]
  howtos = howtos.filter((h) => h.moderation == 'accepted');
  const tags = data.v3_tags;
  howtos.forEach((howto: IHowto) => {
    const howtoTags: IOATag[] = []
    for (const ht in howto.tags) {
      const gt: any = tags.find((t) => t._id === ht) || { label: 'untagged' }
      gt && howtoTags.push(gt.label || "")
    }
    howto.user = data.v3_mappins.find((u) => u._id == howto._createdBy);
    howto.tags = howtoTags;
    howto.category = howto.category || {
      label: 'uncategorized'
    }
  })
  howtos = howtos.filter((h:IHowto) => {
    return h.steps.length > 0 && !blacklist.includes(h._createdBy);
  });
  return howtos
}

export const defaults = async (data: any, cwd: string, root: string) => {
  let defaultsJSON = await findUp('defaults.json', {
    stopAt: root,
    cwd: cwd
  });
  try {
    if (defaultsJSON) {
      data = {
        ...read(defaultsJSON, 'json') as any,
        ...data,
      };
    }
  } catch (error) {
  }
  return data;
};

const onItem = async (store: any, ctx: LoaderContext) => {
  const item = store.data.item as IHowto
  item.steps = item.steps || []
  item.cover_image && (item.cover_image.src = await asset_local_rel(item, item.cover_image))
  item.steps = await pMap(item.steps, async (step) => {
    step.images = await pMap(step.images, async (image) => {
      return {
        ...image,
        src: await asset_local_rel(item, image) || default_image().src,
        alt: image.name || ''
      };
    }, {
      concurrency: 1
    });
    return step;
  }, { concurrency: 1 })

  item.steps.forEach((step) => {
    step.images = step.images.filter((image) => asset_local_abs(item, image))
  })

  item.files = await downloadFiles(item.slug, item)
  return item
}

export function loader(): Loader {

  const load = async ({
    config,
    logger,
    watcher,
    parseData,
    store,
    generateDigest }: LoaderContext) => {

    store.clear()
    let items = await howtos()
    for (const item of items) {
      const id = item.slug
      const data = {
        slug: item.slug,
        id,
        title: item.title,
        type: ITEM_TYPE,
        components: [],
        item
      }
      //const parsedData = await parseData({ id, data: data });        
      const storeItem = {
        digest: await generateDigest(data),
        filePath: id,
        id: `${item.slug}`,
        data: data
      }

      await onItem(storeItem, {
        logger,
        watcher,
        parseData,
        store,
        generateDigest
      } as any)

      storeItem.data['config'] = JSON.stringify(storeItem.data, null, 2)
      store.set(storeItem)
    }
  }
  return {
    name: `astro:store:${ITEN_TYPE}`,
    load
  };
}

///////////////////////////////
//
// Filters

const urlBlacklist = ["thenounproject.com", "preciousplastic.com"];
const bannedWords = ["wizard", "magic2"];
const wordReplaceMap: Record<string, string> = {
  Router: "CNC Router",
  "laptop stand": "laptoppie",
};
export const shortenUrl = (url: string): string => {
  try {
    const { hostname, pathname } = new URL(url);
    const cleanHost = hostname.replace(/^www\./, '');
    const cleanPath = pathname.replace(/\\/$/, ''); // remove trailing slash
    return `${cleanHost}${decodeURIComponent(cleanPath)}`;
  } catch {
    // If invalid URL, return as-is
    return url;
  }
};
// Turns URLs into clickable links, unless blacklisted
export const renderLinks = (text: string): string =>
  text.replace(/https?:\/\/[^\s<"]+/gi, (url) => {
    const isBlacklisted = urlBlacklist.some((domain) =>
      url.toLowerCase().includes(domain.toLowerCase()),
    );
    return isBlacklisted
      ? "[Link Removed]"
      : `<a class="text-orange-600 underline" href="${url}" target="_blank" rel="noopener noreferrer">${shortenUrl(url)}</a>`;
  });

export const filterBannedPhrases = (text: string): string =>
  bannedWords.reduce(
    (acc, word) => acc.replace(new RegExp(`\\b${word}\\b`, "gi"), "[filtered]"),
    text,
  );

export const replaceWords = (text: string): string =>
  Object.entries(wordReplaceMap).reduce(
    (acc, [word, replacement]) =>
      acc.replace(new RegExp(`\\b${word}\\b`, "gi"), replacement),
    text,
  );

export const filters = [
  renderLinks,
  filterBannedPhrases,
  replaceWords,
  HOWTO_FILTER_LMM ? language : (text: string) => text,
];

export async function applyFilters(text: string): Promise<string> {
  let filtered = text;
  for (const filterFn of filters) {
    filtered = await filterFn(filtered);
  }
  return filtered;
}" + } + }, + "parsed_arguments": null, + "timestamp": "2025-03-23T15:04:29.545Z", + "sessionId": "1742741942861", + "prompt": "./prompt.md" + }, + "timestamp": "2025-03-23T15:04:29.547Z", + "service": "collector:onToolCall" + }, + { + "level": "debug", + "message": { + "name": "write_file", + "arguments": { + "file": { + "path": "../base/kbot.ts", + "content": "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" + } + }, + "parsed_arguments": null, + "timestamp": "2025-03-23T15:14:38.656Z", + "sessionId": "1742742724029", + "prompt": "./prompt.md" + }, + "timestamp": "2025-03-23T15:14:38.658Z", + "service": "collector:onToolCall" } ] \ No newline at end of file diff --git a/src/model/howto.sh b/src/model/howto.sh index d10bca4..279cf6f 100644 --- a/src/model/howto.sh +++ b/src/model/howto.sh @@ -1,6 +1,7 @@ kbotd --preferences ./todos.md \ --include=./howto.ts \ - --include=./howto.ts \ + --include=./../base/kbot.ts \ + --include=./howto-model.ts \ --include=./howto_sample.json \ --disable=terminal,git,npm,user,interact,search,email,web \ --disableTools=read_file,read_files,list_files,file_exists,web \ diff --git a/src/model/howto.ts b/src/model/howto.ts index e848a61..ae843b4 100644 --- a/src/model/howto.ts +++ b/src/model/howto.ts @@ -5,11 +5,11 @@ import { sync as read } from '@polymech/fs/read' import { sync as exists } from '@polymech/fs/exists' import { sync as mkdir } from '@polymech/fs/dir' import { sync as rm } from '@polymech/fs/remove' -import { IHowto, Image, IOATag } from './howto-model.js'; +import { IHowto, Image, IOATag, ITEM_TYPE } from './howto-model.js'; import type { Loader, LoaderContext } from 'astro/loaders' import { sanitizeFilename } from "@polymech/fs/utils" -import { filter as language } from "@/base/kbot.js"; export * from './howto-model.js' +import { filter as language } from "@/base/kbot.js"; import { HOWTO_FILES_WEB, @@ -32,8 +32,6 @@ import pMap from 'p-map' import { HOWTO_MIGRATION } from '@/app/config.js' import { createWriteStream } from 'fs'; -export const ITEM_TYPE = 'howto' - //export const load = () => get(`${HOWTO_ROOT()}/${HOWTO_GLOB}`, HOWTO_ROOT(), ITEM_TYPE) export const item_path = (item: any) => `${HOWTO_ROOT()}/${item.data.slug}` diff --git a/src/model/todos.md b/src/model/todos.md index 3f9ab70..52f2557 100644 --- a/src/model/todos.md +++ b/src/model/todos.md @@ -5,10 +5,9 @@ ## Todos -Detail.astro +Modify ../base/kbot.ts -- [ ] when rendering howto.steps, apply a list of filters (some are async) - - [ ] replace all crlf with html line breaks - - [ ] render links via - - [ ] let me transform or reject links (black list) - - [ ] let me filter certain step descriptions for certain words/phrases +- [ ] add new AI templates + - [ ] extract required tools, hardware (complete content of an howto will be provided, to be passed to an AI, returning json data, choose the right structure) + - [ ] extract required skills(complete content of an howto will be provided, to be passed to an AI, returning json data, choose the right structure) + - [ ] learned/gained skills (complete content of an howto will be provided, to be passed to an AI, returning json data, choose the right structure)