- import { t } from '$lib/i18n';
- import { appVersion, showChangelog, updateAvailable, latestVersion } from '$lib/stores';
-
- const REPO_URL = 'https://github.com/open-webui/computer';
- const SHARE_TEXT = 'Check out Computer. Your computer, from anywhere.';
-
- const shareLinks = [
- {
- label: 'X',
- href: `https://x.com/intent/tweet?text=${encodeURIComponent(SHARE_TEXT)}&url=${encodeURIComponent(REPO_URL)}`
- },
- {
- label: 'Reddit',
- href: `https://reddit.com/submit?url=${encodeURIComponent(REPO_URL)}&title=${encodeURIComponent(SHARE_TEXT)}`
- },
- {
- label: 'LinkedIn',
- href: `https://www.linkedin.com/sharing/share-offsite/?url=${encodeURIComponent(REPO_URL)}`
- }
- ];
-
- let copied = $state(false);
-
- function copyLink() {
- navigator.clipboard.writeText(REPO_URL);
- copied = true;
- setTimeout(() => (copied = false), 2000);
- }
-
-
-
- {$t('about.title')}
-
-
-
-
-
-
{$t('about.share')}
- {#each shareLinks as link, i}
- {#if i > 0}
-
·
- {/if}
-
{link.label}
- {/each}
-
·
-
- {copied ? $t('about.copied') : $t('about.copyLink')}
-
-
- {$t('about.createdBy')}
-
diff --git a/cptr/frontend/src/lib/components/Settings/General.svelte b/cptr/frontend/src/lib/components/Settings/General.svelte
index ac7dc2f..d51c1b1 100644
--- a/cptr/frontend/src/lib/components/Settings/General.svelte
+++ b/cptr/frontend/src/lib/components/Settings/General.svelte
@@ -1,15 +1,130 @@
diff --git a/cptr/frontend/src/lib/components/Settings/PWA.svelte b/cptr/frontend/src/lib/components/Settings/PWA.svelte
index e746410..d3d7360 100644
--- a/cptr/frontend/src/lib/components/Settings/PWA.svelte
+++ b/cptr/frontend/src/lib/components/Settings/PWA.svelte
@@ -22,28 +22,6 @@
(e.currentTarget as HTMLSelectElement).value as PwaPreferences['importDestination']
);
}
-
- let resetting = $state(false);
-
- async function resetPwa() {
- resetting = true;
-
- try {
- if ('serviceWorker' in navigator) {
- const registrations = await navigator.serviceWorker.getRegistrations();
- await Promise.all(registrations.map((registration) => registration.unregister()));
- }
-
- if ('caches' in window) {
- const keys = await caches.keys();
- await Promise.all(
- keys.filter((key) => key.startsWith('cptr-')).map((key) => caches.delete(key))
- );
- }
- } finally {
- location.reload();
- }
- }
@@ -80,17 +58,5 @@
updatePref('importFolder', (e.currentTarget as HTMLInputElement).value || undefined)}
/>
{/if}
-
-
{tr('pwa.resetTitle')}
-
- {resetting ? tr('pwa.resetting') : tr('pwa.reset')}
-
-
- {tr('pwa.resetDesc')}
-
{#if activeTab === 'general'}
-
+
{:else if activeTab === 'notifications'}
{:else if activeTab === 'appearance'}
@@ -193,8 +194,6 @@
{:else if activeTab === 'account'}
- {:else if activeTab === 'about'}
-
{:else if activeTab === 'users'}
{:else if activeTab === 'connections'}
@@ -203,6 +202,8 @@
{:else if activeTab === 'models'}
+ {:else if activeTab === 'skills'}
+
{:else if activeTab === 'messaging'}
{:else if activeTab === 'gateway'}
diff --git a/cptr/frontend/src/lib/components/chat/AssistantMessage.svelte b/cptr/frontend/src/lib/components/chat/AssistantMessage.svelte
index 5eb73b1..bc0de9c 100644
--- a/cptr/frontend/src/lib/components/chat/AssistantMessage.svelte
+++ b/cptr/frontend/src/lib/components/chat/AssistantMessage.svelte
@@ -28,6 +28,7 @@
speaking?: boolean;
onapprove: (messageId: string, callId: string, approved: boolean) => void;
onnavigate?: (direction: -1 | 1) => void;
+ onfork?: () => void;
onregenerate?: () => void;
onedit?: (content: string, output: any[] | null, submit: boolean) => void;
onspeak?: () => void;
@@ -45,6 +46,7 @@
speaking = false,
onapprove,
onnavigate,
+ onfork,
onregenerate,
onedit,
onspeak
@@ -603,6 +605,7 @@
disabled={siblingIndex === 0}
onclick={() => onnavigate?.(-1)}
aria-label={$t('chat.prevResponse')}
+ use:tooltip={$t('chat.prevResponse')}
>
onnavigate?.(1)}
aria-label={$t('chat.nextResponse')}
+ use:tooltip={$t('chat.nextResponse')}
>
{#if copied}
{/if}
+ {#if done && onfork}
+
+
+ {/if}
{#if done && usage && Object.keys(usage).length > 0}
(showUsageTooltip = true)}
onmouseleave={() => (showUsageTooltip = false)}
aria-label={$t('chat.usageInfo')}
+ use:tooltip={$t('chat.usageInfo')}
>
void;
oncompact?: () => void;
+ onfork?: () => void;
onplan?: () => void;
onstatus?: () => void;
onskillslist?: () => void;
@@ -92,8 +94,10 @@
contextUsage = null,
tasks = [],
queuedMessages = [],
+ hasChatContent = false,
onsend,
oncompact,
+ onfork,
onplan,
onstatus,
onskillslist,
@@ -356,23 +360,32 @@
let skillActiveClientRectFn: (() => DOMRect | null) | null = null;
let skillRepositionRafId: number | null = null;
let cachedSkills: SkillMentionAttrs[] | null = null;
+ let cachedSkillsWorkspace = '';
+ let slashSkillSuggestions = $state([]);
+ let slashSkillsRequestId = 0;
+
+ async function getCachedSkills(): Promise {
+ if (!workspace) return [];
+ if (!cachedSkills || cachedSkillsWorkspace !== workspace) {
+ const data = await getSkills(workspace);
+ cachedSkills = data.map((s) => ({
+ id: s.name,
+ label: s.name,
+ description: s.description,
+ source: s.source
+ }));
+ cachedSkillsWorkspace = workspace;
+ }
+ return cachedSkills;
+ }
async function fetchSkillSuggestions({ query }: { query: string }): Promise {
if (!workspace) return [];
try {
- // Cache skills list (small, doesn't change during a session)
- if (!cachedSkills) {
- const data = await getSkills(workspace);
- cachedSkills = data.map((s) => ({
- id: s.name,
- label: s.name,
- description: s.description,
- source: s.source
- }));
- }
- if (!query) return cachedSkills;
+ const skills = await getCachedSkills();
+ if (!query) return skills;
const q = query.toLowerCase();
- return cachedSkills.filter(
+ return skills.filter(
(s) => s.label.toLowerCase().includes(q) || (s.description || '').toLowerCase().includes(q)
);
} catch {
@@ -545,19 +558,19 @@
if (event.key === 'ArrowDown') {
event.preventDefault();
selectedSlashCommandIndex =
- (selectedSlashCommandIndex + 1) % Math.max(slashCommandIds.length, 1);
+ (selectedSlashCommandIndex + 1) % Math.max(slashSuggestionIds.length, 1);
return true;
}
if (event.key === 'ArrowUp') {
event.preventDefault();
selectedSlashCommandIndex =
- (selectedSlashCommandIndex - 1 + slashCommandIds.length) %
- Math.max(slashCommandIds.length, 1);
+ (selectedSlashCommandIndex - 1 + slashSuggestionIds.length) %
+ Math.max(slashSuggestionIds.length, 1);
return true;
}
if (event.key === 'Enter') {
event.preventDefault();
- runSlashCommand(slashCommandIds[selectedSlashCommandIndex]);
+ runSlashSuggestion(slashSuggestionIds[selectedSlashCommandIndex]);
return true;
}
}
@@ -930,35 +943,115 @@
const slashCommandIds = $derived.by(() => {
if (!slashCommandQuery.startsWith('/')) return [];
const ids: string[] = [];
- if (oncompact && '/compact'.startsWith(slashCommandQuery)) ids.push('compact');
+ if (hasChatContent && oncompact && '/compact'.startsWith(slashCommandQuery))
+ ids.push('compact');
if (onplan && '/plan'.startsWith(slashCommandQuery)) ids.push('plan');
- if (onstatus && '/status'.startsWith(slashCommandQuery)) ids.push('status');
+ if (hasChatContent && onfork && '/fork'.startsWith(slashCommandQuery)) ids.push('fork');
+ if (hasChatContent && onstatus && '/status'.startsWith(slashCommandQuery)) ids.push('status');
if (
+ hasChatContent &&
onskillslist &&
slashCommandQuery !== '/skills:list' &&
'/skills:list'.startsWith(slashCommandQuery)
)
ids.push('skills:list');
- if (slashCommandQuery !== '/skills:create' && '/skills:create'.startsWith(slashCommandQuery))
+ if (
+ hasChatContent &&
+ slashCommandQuery !== '/skills:create' &&
+ '/skills:create'.startsWith(slashCommandQuery)
+ )
ids.push('skills:create');
return ids;
});
- const showSlashCommands = $derived(slashCommandIds.length > 0);
+ const slashSuggestionIds = $derived([
+ ...slashCommandIds.map((id) => `command:${id}`),
+ ...slashSkillSuggestions.map((skill) => `skill:${skill.id}`)
+ ]);
+ const showSlashCommands = $derived(slashSuggestionIds.length > 0);
const contextPercent = $derived(Math.max(0, Math.round(contextUsage?.percent ?? 0)));
const contextCirclePercent = $derived(Math.min(contextPercent, 100));
const contextCircleOffset = $derived(50.27 * (1 - contextCirclePercent / 100));
$effect(() => {
- if (selectedSlashCommandIndex >= slashCommandIds.length) selectedSlashCommandIndex = 0;
+ if (selectedSlashCommandIndex >= slashSuggestionIds.length) selectedSlashCommandIndex = 0;
});
+ $effect(() => {
+ const query = slashCommandQuery;
+ const requestId = ++slashSkillsRequestId;
+ if (!query.startsWith('/') || !workspace) {
+ slashSkillSuggestions = [];
+ return;
+ }
+ void fetchSkillSuggestions({ query: query.slice(1) }).then((items) => {
+ if (requestId !== slashSkillsRequestId) return;
+ slashSkillSuggestions = items.slice(0, 5);
+ });
+ });
+
+ function selectedSlashCommand(commandId: string) {
+ return slashSuggestionIds[selectedSlashCommandIndex] === `command:${commandId}`;
+ }
+
+ function selectSlashCommand(commandId: string) {
+ selectedSlashCommandIndex = slashSuggestionIds.indexOf(`command:${commandId}`);
+ }
+
+ function selectedSlashSkill(skillId: string) {
+ return slashSuggestionIds[selectedSlashCommandIndex] === `skill:${skillId}`;
+ }
+
+ function selectSlashSkill(skillId: string) {
+ selectedSlashCommandIndex = slashSuggestionIds.indexOf(`skill:${skillId}`);
+ }
+
+ function runSlashSuggestion(suggestionId: string | undefined) {
+ if (suggestionId?.startsWith('skill:')) {
+ const skillId = suggestionId.slice('skill:'.length);
+ const skill = slashSkillSuggestions.find((item) => item.id === skillId);
+ runSlashSkill(skill ?? { id: skillId, label: skillId });
+ return;
+ }
+ runSlashCommand(suggestionId?.replace(/^command:/, ''));
+ }
+
+ function runSlashSkill(skill: SkillMentionAttrs) {
+ if (!editor || editor.isDestroyed) {
+ inputText = `$${skill.label} `;
+ return;
+ }
+ editor
+ .chain()
+ .focus()
+ .clearContent()
+ .insertContent([
+ {
+ type: 'skillMention',
+ attrs: {
+ id: skill.id,
+ label: skill.label,
+ description: skill.description,
+ source: skill.source
+ }
+ },
+ { type: 'text', text: ' ' }
+ ])
+ .run();
+ }
+
function runSlashCommand(commandId: string | undefined) {
if (commandId === 'compact' && (sending || streaming)) return;
+ if (commandId === 'fork' && (sending || streaming)) return;
if (commandId === 'compact' && oncompact) {
inputText = '';
oncompact();
return;
}
+ if (commandId === 'fork' && onfork) {
+ inputText = '';
+ onfork();
+ return;
+ }
if (commandId === 'plan' && onplan) {
inputText = '';
onplan();
@@ -982,7 +1075,7 @@
}
function handleSubmit() {
- runSlashCommand(slashCommandIds[0]);
+ runSlashSuggestion(slashSuggestionIds[0]);
}
// Allow sending during streaming (message will be enqueued server-side)
@@ -1033,9 +1126,11 @@
-
- {$t('chat.commands')}
-
+ {#if slashCommandIds.length > 0}
+
+ {$t('chat.commands')}
+
+ {/if}
{#if slashCommandIds.includes('compact')}
e.preventDefault()}
onclick={() => {
runSlashCommand('compact');
}}
- onmouseenter={() => (selectedSlashCommandIndex = slashCommandIds.indexOf('compact'))}
+ onmouseenter={() => selectSlashCommand('compact')}
>
@@ -1096,12 +1189,12 @@
placement: 'right'
}}
class="slash-command-row flex items-center gap-2 w-full h-6 px-2 rounded-xl text-xs text-left transition-colors duration-75
- {slashCommandIds[selectedSlashCommandIndex] === 'plan' ? 'app-interactive-active' : ''}"
+ {selectedSlashCommand('plan') ? 'app-interactive-active' : ''}"
onmousedown={(e) => e.preventDefault()}
onclick={() => {
runSlashCommand('plan');
}}
- onmouseenter={() => (selectedSlashCommandIndex = slashCommandIds.indexOf('plan'))}
+ onmouseenter={() => selectSlashCommand('plan')}
>
{/if}
+ {#if slashCommandIds.includes('fork')}
+
e.preventDefault()}
+ onclick={() => {
+ runSlashCommand('fork');
+ }}
+ onmouseenter={() => selectSlashCommand('fork')}
+ >
+
+
+
+ {$t('chat.commandFork')}
+
+ {$t('chat.commandForkDesc')}
+
+
+
+ {/if}
{#if slashCommandIds.includes('status')}
e.preventDefault()}
onclick={() => {
runSlashCommand('status');
}}
- onmouseenter={() => (selectedSlashCommandIndex = slashCommandIds.indexOf('status'))}
+ onmouseenter={() => selectSlashCommand('status')}
>
e.preventDefault()}
onclick={() => {
runSlashCommand('skills:list');
}}
- onmouseenter={() => (selectedSlashCommandIndex = slashCommandIds.indexOf('skills:list'))}
+ onmouseenter={() => selectSlashCommand('skills:list')}
>
{/if}
+ {#if slashSkillSuggestions.length > 0}
+
Skills
+ {#each slashSkillSuggestions as skill (skill.id)}
+
e.preventDefault()}
+ onclick={() => {
+ runSlashSkill(skill);
+ }}
+ onmouseenter={() => selectSlashSkill(skill.id)}
+ >
+
+
+
+ {skill.label}
+ {#if skill.source && skill.source !== 'workspace'}
+ {skill.source}
+ {/if}
+
+
+ {/each}
+ {/if}
onnavigate?.(1)}
aria-label={$t('chat.nextMessage')}
+ use:tooltip={$t('chat.nextMessage')}
>
{#if copied}
str:
)
-def _apply_skills_create_prompt(messages: list[dict]) -> bool:
+def _message_has_real_content(message: dict) -> bool:
+ text = _plain_message_text(message.get("content")).strip()
+ if message.get("role") == "user" and text.startswith("/"):
+ return False
+ return bool(
+ text or message.get("tool_calls") or message.get("reasoning_items") or message.get("output")
+ )
+
+
+def _has_prior_real_chat_content(messages: list[dict], loaded_summary: str | None = None) -> bool:
+ if loaded_summary and loaded_summary.strip():
+ return True
+ last_user_idx = next(
+ (idx for idx in range(len(messages) - 1, -1, -1) if messages[idx].get("role") == "user"),
+ len(messages),
+ )
+ return any(
+ message.get("role") == "user" and _message_has_real_content(message)
+ for message in messages[:last_user_idx]
+ )
+
+
+def _build_skill_create_gate_prompt(reason: str = "empty_chat") -> str:
+ if reason == "disabled":
+ return (
+ "[/skills:create] Skill creation is disabled in admin settings. "
+ "Explain this briefly and do not try to create or update a skill."
+ )
+ return (
+ "[/skills:create] The user tried to create a skill before this chat had "
+ "any prior real content. Explain briefly that skill creation needs an "
+ "existing chat with the workflow or source material already in it, then "
+ "ask them to continue in a chat with content first."
+ )
+
+
+def _apply_skills_create_prompt(
+ messages: list[dict],
+ *,
+ allowed: bool,
+ denial_reason: str = "empty_chat",
+) -> bool:
for message in reversed(messages):
if message.get("role") != "user":
continue
@@ -171,7 +219,11 @@ def _apply_skills_create_prompt(messages: list[dict]) -> bool:
match = SKILLS_CREATE_RE.match(text.strip())
if not match:
return False
- message["content"] = _build_skill_create_prompt(match.group(1) or "")
+ message["content"] = (
+ _build_skill_create_prompt(match.group(1) or "")
+ if allowed
+ else _build_skill_create_gate_prompt(denial_reason)
+ )
return True
return False
@@ -1315,6 +1367,16 @@ async def _emit_done():
content = (msg.content or "") if msg else ""
output_items: list[dict] = list(msg.output or []) if msg else []
text_buffer = "" # Accumulates text between tool calls
+ task_completed_success = False
+ review_messages: list[dict] = []
+ review_model_connection: dict | None = None
+ review_model_name = ""
+ review_chat_params: dict = {}
+ review_builtin_tools: dict | None = None
+ loaded_skill_names: set[str] = set()
+ tool_names_used: set[str] = set()
+ skill_create_requested = False
+ skill_authoring_allowed = False
logger.info(
"[task %s] start: existing content=%d chars, output=%d items",
@@ -1391,7 +1453,8 @@ async def save_session(agent_target: AgentModelTarget, resume_state: dict | None
await Chat.update_meta(chat_id, meta, now_ms())
async def _run_agent_target(agent_target: AgentModelTarget):
- nonlocal content, text_buffer
+ nonlocal content, text_buffer, task_completed_success, skill_authoring_allowed
+ nonlocal skill_create_requested
from cptr.utils.agents.claude_code import run_claude_code_agent
from cptr.utils.agents.cline import run_cline_agent
from cptr.utils.agents.codex import run_codex_agent
@@ -1402,7 +1465,15 @@ async def _run_agent_target(agent_target: AgentModelTarget):
chat_obj = await Chat.get_by_id(chat_id)
chat_params = (chat_obj.meta or {}).get("params", {}) if chat_obj else {}
messages, loaded_summary = await _load_message_history(chat_id, message_id)
- _apply_skills_create_prompt(messages)
+ skill_settings = await get_skill_settings()
+ skill_authoring_allowed = _has_prior_real_chat_content(messages, loaded_summary)
+ skill_create_denial_reason = "empty_chat"
+ if not skill_settings["enabled"] or not skill_settings["tool_enabled"]:
+ skill_authoring_allowed = False
+ skill_create_denial_reason = "disabled"
+ skill_create_requested = _apply_skills_create_prompt(
+ messages, allowed=skill_authoring_allowed, denial_reason=skill_create_denial_reason
+ )
memory_message, memory_files = _memory_recall_inputs(messages, regeneration_prompt)
system = await _load_system_prompt(
workspace,
@@ -1629,6 +1700,7 @@ async def _run_agent_target(agent_target: AgentModelTarget):
data={"workspace": event_workspace, "preview": preview},
message=preview,
)
+ task_completed_success = True
return
flushed_item = _flush_text()
@@ -1669,7 +1741,15 @@ async def _run_agent_target(agent_target: AgentModelTarget):
chat_models_config = {}
builtin_tools = resolve_builtin_tools_config(chat_models_config, model, configured_model)
messages, loaded_summary = await _load_message_history(chat_id, message_id)
- _apply_skills_create_prompt(messages)
+ skill_settings = await get_skill_settings()
+ skill_authoring_allowed = _has_prior_real_chat_content(messages, loaded_summary)
+ skill_create_denial_reason = "empty_chat"
+ if not skill_settings["enabled"] or not skill_settings["tool_enabled"]:
+ skill_authoring_allowed = False
+ skill_create_denial_reason = "disabled"
+ skill_create_requested = _apply_skills_create_prompt(
+ messages, allowed=skill_authoring_allowed, denial_reason=skill_create_denial_reason
+ )
memory_message, memory_files = _memory_recall_inputs(messages, regeneration_prompt)
system = await _load_system_prompt(
workspace,
@@ -1684,9 +1764,11 @@ async def _run_agent_target(agent_target: AgentModelTarget):
if regeneration_prompt:
messages.append({"role": "user", "content": regeneration_prompt})
tools = await get_tool_list(builtin_tools=builtin_tools)
+ if not skill_authoring_allowed:
+ tools = [t for t in tools if t["name"] != "manage_skill"]
# Remove view_skill tool if no skills are available
- skills = discover_skills(workspace)
+ skills = discover_skills(workspace) if skill_settings["enabled"] else []
if not skills:
tools = [t for t in tools if t["name"] != "view_skill"]
@@ -1717,6 +1799,8 @@ async def _run_agent_target(agent_target: AgentModelTarget):
if skill:
skill_blocks.append(format_skill_content(skill))
_activated_skills.add(sid) # mark as activated for dedup
+ loaded_skill_names.add(sid)
+ bump_skill_view(workspace, sid, skill.source)
if skill_blocks:
system += "\n\n" + "\n\n".join(skill_blocks)
@@ -1733,6 +1817,14 @@ async def _run_agent_target(agent_target: AgentModelTarget):
logger.info(
"[task %s] plan mode active, %d tools available", message_id[:8], len(tools)
)
+ review_messages = messages
+ review_model_connection = connection
+ review_model_name = model
+ review_chat_params = {
+ **chat_params,
+ "subagent": bool(chat_obj and (chat_obj.meta or {}).get("subagent")),
+ }
+ review_builtin_tools = builtin_tools
# Tool approval mode: 'ask' | 'auto' | 'full'
# ask = require approval for ALL tools (including reads)
@@ -1959,6 +2051,7 @@ async def _run_agent_target(agent_target: AgentModelTarget):
data={"workspace": event_workspace, "preview": preview},
message=preview,
)
+ task_completed_success = True
return
# ── Process collected tool calls ────────────────────
@@ -1987,6 +2080,11 @@ async def _run_agent_target(agent_target: AgentModelTarget):
needs_approval = None
for tc in pending_calls:
name = tc["name"]
+ tool_names_used.add(name)
+ if name == "view_skill":
+ skill_name = str(tc.get("arguments", {}).get("skill_name") or "").strip()
+ if skill_name:
+ loaded_skill_names.add(skill_name)
tool = ALL_TOOLS.get(name)
should_auto = approval_mode == "full" or (
approval_mode == "auto" and tool and tool["auto"]
@@ -2190,6 +2288,7 @@ async def _run_agent_target(agent_target: AgentModelTarget):
data={"workspace": event_workspace, "preview": preview},
message=preview,
)
+ task_completed_success = True
return
# Max iterations reached
@@ -2320,6 +2419,26 @@ async def _run_agent_target(agent_target: AgentModelTarget):
)
except Exception:
logger.debug("[memory] Failed to review conversation", exc_info=True)
+ try:
+ from cptr.utils.skills import review_skills_after_turn
+
+ await review_skills_after_turn(
+ workspace=workspace,
+ conversation_messages=review_messages,
+ assistant_reply=content,
+ model_connection=review_model_connection,
+ model=review_model_name,
+ loaded_skill_names=loaded_skill_names,
+ tool_names=tool_names_used,
+ skill_create_requested=skill_create_requested,
+ plan_mode=bool(review_chat_params.get("plan_mode")),
+ subagent=bool(review_chat_params.get("subagent")),
+ skills_enabled=task_completed_success
+ and skill_authoring_allowed
+ and "manage_skill" not in disabled_builtin_tool_names(review_builtin_tools),
+ )
+ except Exception:
+ logger.debug("[skills] Failed to review conversation", exc_info=True)
# Process any pending user prompts or internal subagent results.
try:
await process_pending_chat_inputs(chat_id, user_id, workspace)
diff --git a/cptr/utils/prompt_templates.py b/cptr/utils/prompt_templates.py
index 8d82e95..e3fb559 100644
--- a/cptr/utils/prompt_templates.py
+++ b/cptr/utils/prompt_templates.py
@@ -208,7 +208,12 @@ def _render_system_template(template: str, variables: dict[str, str]) -> str:
return re.sub(r"\n{3,}", "\n\n", rendered).strip()
-def _build_template_variables(workspace: str, model: str = "", memory: str = "") -> dict[str, str]:
+def _build_template_variables(
+ workspace: str,
+ model: str = "",
+ memory: str = "",
+ skills_enabled: bool = True,
+) -> dict[str, str]:
"""Build the dict of template variable values for the current context."""
ws_path = Path(workspace)
os_name = platform.system().replace("Darwin", "macOS")
@@ -225,8 +230,7 @@ def _build_template_variables(workspace: str, model: str = "", memory: str = "")
else:
instructions_block = ""
- skills = discover_skills(workspace)
- skills_block = build_catalog_xml(skills)
+ skills_block = build_catalog_xml(discover_skills(workspace)) if skills_enabled else ""
return {
"WORKSPACE_NAME": ws_path.name if ws_path.is_dir() else "",
@@ -310,5 +314,10 @@ async def load_system_prompt(
if memory and "{{MEMORY}}" not in template:
template = template.rstrip() + "\n\n{{MEMORY}}"
- variables = _build_template_variables(workspace, model, memory)
+ try:
+ skills_enabled = (await Config.get("skills.enabled")) not in (False, "false", "0")
+ except Exception:
+ skills_enabled = True
+
+ variables = _build_template_variables(workspace, model, memory, skills_enabled)
return _render_system_template(template, variables)
diff --git a/cptr/utils/skills.py b/cptr/utils/skills.py
index 3fa9259..4150bb6 100644
--- a/cptr/utils/skills.py
+++ b/cptr/utils/skills.py
@@ -14,10 +14,16 @@
from __future__ import annotations
+import asyncio
import logging
+import json
+import os
import re
+import shutil
+import time
from dataclasses import dataclass, field
-from typing import Literal
+from datetime import datetime, timezone
+from typing import Any, Literal
from pathlib import Path
import yaml
@@ -43,6 +49,22 @@
MANAGED_WORKSPACE_SKILL_DIR = ".cptr/skills"
MANAGED_GLOBAL_SKILL_DIR = Path.home() / ".cptr" / "skills"
ALLOWED_BUNDLE_DIRS = {"references", "templates", "scripts", "assets"}
+DEFAULT_SKILL_SETTINGS: dict[str, Any] = {
+ "enabled": True,
+ "tool_enabled": True,
+ "background_review_enabled": True,
+ "review_interval_turns": 10,
+}
+SKILL_USAGE_DEFAULT: dict[str, Any] = {
+ "created_from": None,
+ "view_count": 0,
+ "use_count": 0,
+ "update_count": 0,
+ "last_viewed_at": None,
+ "last_used_at": None,
+ "last_updated_at": None,
+}
+USAGE_FILE_NAME = "usage.json"
# Directories to skip during scanning
_SKIP_DIRS = {".git", "node_modules", "__pycache__", ".venv", "venv"}
@@ -69,6 +91,14 @@ class SkillMeta:
metadata: dict | None = None
allowed_tools: str | None = None
managed: bool = False
+ created_by: str | None = None
+ created_from: str | None = None
+ view_count: int = 0
+ use_count: int = 0
+ update_count: int = 0
+ last_viewed_at: str | None = None
+ last_used_at: str | None = None
+ last_updated_at: str | None = None
@dataclass
@@ -133,6 +163,115 @@ def parse_frontmatter(text: str) -> tuple[dict, str]:
return {}, body
+def _usage_path(workspace: str, source: str) -> Path:
+ if source == "global":
+ return MANAGED_GLOBAL_SKILL_DIR.expanduser().parent / USAGE_FILE_NAME
+ if not workspace:
+ raise ValueError("workspace is required for workspace usage")
+ return Path(workspace).expanduser().resolve() / ".cptr" / USAGE_FILE_NAME
+
+
+def read_usage(workspace: str, source: str = "workspace") -> dict[str, Any]:
+ path = _usage_path(workspace, source)
+ if not path.is_file():
+ return {"version": 1, "skills": {}}
+ try:
+ data = json.loads(path.read_text(encoding="utf-8"))
+ except (OSError, json.JSONDecodeError):
+ return {"version": 1, "skills": {}}
+ if not isinstance(data, dict):
+ return {"version": 1, "skills": {}}
+ skills = data.get("skills")
+ if not isinstance(skills, dict):
+ skills = {}
+ return {"version": 1, "skills": skills}
+
+
+def write_usage(workspace: str, source: str, data: dict[str, Any]) -> None:
+ path = _usage_path(workspace, source)
+ path.parent.mkdir(parents=True, exist_ok=True)
+ tmp = path.with_name(f".{path.name}.{os.getpid()}.{time.time_ns()}.tmp")
+ tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+ os.replace(tmp, path)
+
+
+def bump_skill_view(workspace: str, name: str, source: str = "workspace", *, used: bool = True) -> None:
+ try:
+ data = read_usage(workspace, source)
+ skills = data.setdefault("skills", {})
+ rec = skills.setdefault(name, dict(SKILL_USAGE_DEFAULT))
+ now = datetime.now(timezone.utc).isoformat()
+ rec["view_count"] = int(rec.get("view_count") or 0) + 1
+ rec["last_viewed_at"] = now
+ if used:
+ rec["use_count"] = int(rec.get("use_count") or 0) + 1
+ rec["last_used_at"] = now
+ write_usage(workspace, source, data)
+ except Exception:
+ logger.debug("[skills] Failed to bump view usage for %s", name, exc_info=True)
+
+
+def bump_skill_update(
+ workspace: str,
+ name: str,
+ source: str = "workspace",
+ *,
+ created_from: str | None = None,
+) -> None:
+ try:
+ data = read_usage(workspace, source)
+ skills = data.setdefault("skills", {})
+ rec = skills.setdefault(name, dict(SKILL_USAGE_DEFAULT))
+ rec["update_count"] = int(rec.get("update_count") or 0) + 1
+ rec["last_updated_at"] = datetime.now(timezone.utc).isoformat()
+ if created_from and not rec.get("created_from"):
+ rec["created_from"] = created_from
+ write_usage(workspace, source, data)
+ except Exception:
+ logger.debug("[skills] Failed to bump update usage for %s", name, exc_info=True)
+
+
+def _frontmatter_bounds(content: str) -> tuple[dict, str] | None:
+ if not content.startswith("---\n"):
+ return None
+ match = re.search(r"\n---\s*\n", content[4:])
+ if not match:
+ return None
+ end = match.start() + 4
+ fm_text = content[4:end]
+ body = content[match.end() + 4 :]
+ try:
+ fm = yaml.safe_load(fm_text) or {}
+ except yaml.YAMLError:
+ fm = {}
+ return fm if isinstance(fm, dict) else {}, body
+
+
+def _with_skill_metadata(
+ content: str,
+ *,
+ created_from: str | None = None,
+ preserve_created: dict | None = None,
+) -> str:
+ parsed = _frontmatter_bounds(content)
+ if not parsed:
+ return content.strip() + "\n"
+ fm, body = parsed
+ now = datetime.now(timezone.utc).isoformat()
+ if preserve_created:
+ for key in ("created_by", "created_from", "created_at"):
+ if preserve_created.get(key) and not fm.get(key):
+ fm[key] = preserve_created[key]
+ if created_from:
+ fm.setdefault("created_by", "computer")
+ fm.setdefault("created_from", created_from)
+ fm.setdefault("created_at", now)
+ if fm.get("created_by") == "computer" or created_from or preserve_created:
+ fm["updated_at"] = now
+ frontmatter = yaml.safe_dump(fm, sort_keys=False, allow_unicode=True).strip()
+ return f"---\n{frontmatter}\n---\n{body.lstrip()}".strip() + "\n"
+
+
# ── Name validation ─────────────────────────────────────────
_NAME_RE = re.compile(r"^[a-z0-9]([a-z0-9-]*[a-z0-9])?$")
@@ -197,6 +336,7 @@ def _scan_skills_dir(skills_dir: Path, source: str, workspace: str = "") -> list
return results
dirs_scanned = 0
+ usage = read_usage(workspace, source).get("skills", {})
try:
for item in sorted(skills_dir.iterdir()):
if dirs_scanned >= _MAX_SCAN_DIRS:
@@ -236,6 +376,9 @@ def _scan_skills_dir(skills_dir: Path, source: str, workspace: str = "") -> list
warnings = validate_name(name, item.name)
for w in warnings:
logger.warning("[skills] %s: %s", skill_md, w)
+ rec = usage.get(name) if isinstance(usage, dict) else {}
+ if not isinstance(rec, dict):
+ rec = {}
results.append(
SkillMeta(
@@ -248,6 +391,14 @@ def _scan_skills_dir(skills_dir: Path, source: str, workspace: str = "") -> list
metadata=fm.get("metadata") if isinstance(fm.get("metadata"), dict) else None,
allowed_tools=fm.get("allowed-tools"),
managed=_is_managed_skill(skill_md, workspace),
+ created_by=fm.get("created_by"),
+ created_from=fm.get("created_from"),
+ view_count=int(rec.get("view_count") or 0),
+ use_count=int(rec.get("use_count") or 0),
+ update_count=int(rec.get("update_count") or 0),
+ last_viewed_at=rec.get("last_viewed_at"),
+ last_used_at=rec.get("last_used_at"),
+ last_updated_at=rec.get("last_updated_at"),
)
)
@@ -417,8 +568,10 @@ def create_managed_skill(
name: str,
content: str,
scope: Literal["workspace", "global"] = "workspace",
+ created_from: str | None = None,
) -> dict:
name = _validate_skill_name(name)
+ content = _with_skill_metadata(content, created_from=created_from)
_validate_skill_content(name, content)
if any(skill.name == name for skill in discover_skills(workspace)):
raise ValueError(f"skill '{name}' already exists")
@@ -427,9 +580,31 @@ def create_managed_skill(
if skill_md.exists():
raise ValueError(f"skill '{name}' already exists")
_write_text_atomic(skill_md, content.strip() + "\n")
+ if created_from:
+ bump_skill_update(workspace, name, scope, created_from=created_from)
+ return {"success": True, "name": name, "location": str(skill_md.resolve())}
+
+
+def update_managed_skill(workspace: str, name: str, content: str) -> dict:
+ name = _validate_skill_name(name)
+ skill_dir = _managed_skill_dir(workspace, name)
+ skill_md = skill_dir / "SKILL.md"
+ old = skill_md.read_text(encoding="utf-8", errors="replace") if skill_md.exists() else ""
+ old_fm, _ = parse_frontmatter(old)
+ content = _with_skill_metadata(content, preserve_created=old_fm)
+ _validate_skill_content(name, content)
+ _write_text_atomic(skill_md, content.strip() + "\n")
+ source = "global" if skill_dir.is_relative_to(MANAGED_GLOBAL_SKILL_DIR.expanduser().resolve()) else "workspace"
+ bump_skill_update(workspace, name, source)
return {"success": True, "name": name, "location": str(skill_md.resolve())}
+def delete_managed_skill(workspace: str, name: str) -> dict:
+ skill_dir = _managed_skill_dir(workspace, name)
+ shutil.rmtree(skill_dir)
+ return {"success": True, "name": name}
+
+
def _managed_skill_dir(workspace: str, name: str) -> Path:
name = _validate_skill_name(name)
skill = next((s for s in discover_skills(workspace) if s.name == name), None)
@@ -459,6 +634,8 @@ def write_managed_skill_file(
if not target.is_relative_to(skill_dir):
raise ValueError("file_path escapes the skill")
_write_text_atomic(target, file_content)
+ source = "global" if skill_dir.is_relative_to(MANAGED_GLOBAL_SKILL_DIR.expanduser().resolve()) else "workspace"
+ bump_skill_update(workspace, name, source)
return {"success": True, "name": name, "location": str(target)}
@@ -520,3 +697,182 @@ def format_skill_content(skill: SkillContent) -> str:
parts.append("")
return "\n".join(parts)
+
+
+async def get_skill_settings() -> dict[str, Any]:
+ try:
+ from cptr.models import Config
+
+ raw = await Config.get_namespace("skills")
+ except Exception:
+ raw = {}
+ settings = dict(DEFAULT_SKILL_SETTINGS)
+ for key, value in raw.items():
+ short = key.removeprefix("skills.")
+ settings[short] = value
+ try:
+ settings["review_interval_turns"] = max(1, int(settings["review_interval_turns"]))
+ except (TypeError, ValueError):
+ settings["review_interval_turns"] = DEFAULT_SKILL_SETTINGS["review_interval_turns"]
+ settings["enabled"] = settings.get("enabled") not in (False, "false", "0")
+ settings["tool_enabled"] = settings.get("tool_enabled") not in (False, "false", "0")
+ settings["background_review_enabled"] = settings.get("background_review_enabled") not in (
+ False,
+ "false",
+ "0",
+ )
+ return settings
+
+
+async def review_skills_after_turn(
+ *,
+ workspace: str,
+ conversation_messages: list[dict[str, Any]],
+ assistant_reply: str,
+ model_connection: dict | None,
+ model: str,
+ loaded_skill_names: set[str],
+ tool_names: set[str],
+ skill_create_requested: bool,
+ plan_mode: bool,
+ subagent: bool,
+ skills_enabled: bool,
+) -> None:
+ if (
+ not workspace
+ or not assistant_reply.strip()
+ or not model_connection
+ or plan_mode
+ or subagent
+ or not skills_enabled
+ ):
+ return
+ settings = await get_skill_settings()
+ if (
+ not settings["enabled"]
+ or not settings["tool_enabled"]
+ or not settings["background_review_enabled"]
+ ):
+ return
+ if not tool_names and not skill_create_requested and not loaded_skill_names:
+ return
+ user_turns = sum(1 for message in conversation_messages if message.get("role") == "user")
+ if user_turns <= 0 or user_turns % int(settings["review_interval_turns"]) != 0:
+ return
+ asyncio.create_task(
+ run_skill_review(
+ workspace=workspace,
+ conversation_messages=list(conversation_messages),
+ assistant_reply=assistant_reply,
+ model_connection=dict(model_connection),
+ model=model,
+ loaded_skill_names=set(loaded_skill_names),
+ tool_names=set(tool_names),
+ skill_create_requested=skill_create_requested,
+ )
+ )
+
+
+async def run_skill_review(
+ *,
+ workspace: str,
+ conversation_messages: list[dict[str, Any]],
+ assistant_reply: str,
+ model_connection: dict,
+ model: str,
+ loaded_skill_names: set[str],
+ tool_names: set[str],
+ skill_create_requested: bool,
+) -> None:
+ try:
+ from cptr.utils.ai import chat_completion
+ from cptr.utils.chat_task import _default_base_url
+ from cptr.utils.config import _get_jwt_secret
+ from cptr.utils.crypto import decrypt_key
+ from cptr.utils.json_parser import extract_json
+ from cptr.utils.memory import summarize_recent_conversation
+
+ skills = discover_skills(workspace)
+ transcript = summarize_recent_conversation(conversation_messages, assistant_reply)
+ catalog = "\n".join(
+ f"- {skill.name} ({skill.source}, {'managed' if skill.managed else 'read-only'}): {skill.description}"
+ for skill in skills[:80]
+ ) or "- none"
+ loaded_blocks = []
+ for name in sorted(loaded_skill_names):
+ skill = load_skill(workspace, name)
+ if not skill or not skill.managed:
+ continue
+ content = skill.content
+ if len(content) > 5000:
+ content = content[:4500] + "\n...(truncated)..."
+ loaded_blocks.append(f"## {name}\n{content}")
+ loaded_context = "\n\n".join(loaded_blocks) or "None."
+ prompt = (
+ "Review the completed conversation and decide whether Computer learned a reusable "
+ "workflow that should become or improve a skill. Return ONLY JSON with this shape:\n"
+ '{"actions":[{"action":"create|update|write_file|none","name":"skill-name",'
+ '"reason":"short reason","content":"full SKILL.md for create/update",'
+ '"file_path":"references/example.md","file_content":"support file content"}]}\n\n'
+ "Rules:\n"
+ "- Use action=none when nothing durable was learned.\n"
+ "- Prefer updating a loaded managed skill, then another managed skill, then writing a support file, then creating one new workspace skill.\n"
+ "- Create or update only for reusable procedures, user corrections, durable commands, verification steps, or workflows likely to recur.\n"
+ "- Do not save one-off task summaries, transient local failures, secrets, vague preferences, or project facts better suited for memory.\n"
+ "- Never delete. Never update read-only skills. Never write outside references/, templates/, scripts/, or assets/.\n\n"
+ f"Workspace: {workspace}\n"
+ f"Tools used this turn: {', '.join(sorted(tool_names)) or 'none'}\n"
+ f"/skills:create requested: {skill_create_requested}\n"
+ f"Loaded skills: {', '.join(sorted(loaded_skill_names)) or 'none'}\n\n"
+ f"Available skills:\n{catalog}\n\n"
+ f"Loaded managed skill contents:\n{loaded_context}\n\n"
+ f"Conversation:\n{transcript}"
+ )
+ provider = model_connection["provider"]
+ api_key = decrypt_key(model_connection.get("api_key", ""), _get_jwt_secret())
+ base_url = model_connection.get("base_url") or _default_base_url(provider)
+ text = await chat_completion(
+ provider=provider,
+ base_url=base_url,
+ api_key=api_key,
+ model=model,
+ messages=[{"role": "user", "content": prompt}],
+ system="You are Computer's private skill reviewer. Return only valid JSON.",
+ max_tokens=1800,
+ api_type=model_connection.get("api_type", "chat_completions"),
+ )
+ parsed = extract_json(text)
+ if not isinstance(parsed, dict):
+ return
+ actions = parsed.get("actions")
+ if not isinstance(actions, list):
+ return
+ managed = {skill.name for skill in discover_skills(workspace) if skill.managed}
+ for action in actions[:3]:
+ if not isinstance(action, dict):
+ continue
+ kind = action.get("action")
+ name = str(action.get("name") or "").strip()
+ if kind == "none":
+ continue
+ if kind == "create":
+ content = action.get("content")
+ if isinstance(content, str) and content.strip():
+ create_managed_skill(
+ workspace,
+ name,
+ content,
+ scope="workspace",
+ created_from="background_review",
+ )
+ elif kind == "update":
+ content = action.get("content")
+ if name in managed and isinstance(content, str) and content.strip():
+ update_managed_skill(workspace, name, content)
+ elif kind == "write_file":
+ file_path = action.get("file_path")
+ file_content = action.get("file_content")
+ if name in managed and isinstance(file_path, str) and isinstance(file_content, str):
+ write_managed_skill_file(workspace, name, file_path, file_content)
+ except Exception:
+ logger.debug("[skills] Failed to review conversation for skills", exc_info=True)
diff --git a/cptr/utils/tools.py b/cptr/utils/tools.py
index a78d902..eba3411 100644
--- a/cptr/utils/tools.py
+++ b/cptr/utils/tools.py
@@ -1611,7 +1611,11 @@ async def view_skill(
"""Load the full instructions and resource listing for an available skill.
:param skill_name: The name of the skill to load (from the catalog).
"""
- from cptr.utils.skills import load_skill, format_skill_content
+ from cptr.models import Config
+ from cptr.utils.skills import bump_skill_view, load_skill, format_skill_content
+
+ if (await Config.get("skills.enabled")) in (False, "false", "0"):
+ return "Error: skills are disabled by the administrator."
# Deduplication: if already activated, return short notice
if skill_name in _activated_skills:
@@ -1622,11 +1626,12 @@ async def view_skill(
return f"Error: skill '{skill_name}' not found. Check for valid names."
_activated_skills.add(skill_name)
+ bump_skill_view(workspace, skill_name, skill.source)
return format_skill_content(skill)
async def manage_skill(
- action: Literal["create", "write_file"],
+ action: Literal["create", "update", "write_file", "delete"],
name: str,
content: Optional[str] = None,
scope: Literal["workspace", "global"] = "workspace",
@@ -1635,26 +1640,44 @@ async def manage_skill(
*,
__context__: dict,
) -> str:
- """Create Computer-managed skills and supporting bundle files.
+ """Create, update, or delete Computer-managed skills and supporting bundle files.
- Use this only when the user asks to create a reusable skill. New skills
- default to the current workspace. For supporting files, write only under
- references/, templates/, scripts/, or assets/.
- :param action: "create" to write SKILL.md, or "write_file" to add a bundle file.
+ Use this only when the user asks to create, update, or delete a reusable skill.
+ New skills default to the current workspace. For supporting files, write only
+ under references/, templates/, scripts/, or assets/.
+ :param action: "create" to write SKILL.md, "update" to replace SKILL.md, "write_file" to add a bundle file, or "delete" to remove a managed skill.
:param name: Lowercase hyphenated skill name.
- :param content: Full SKILL.md content for action="create".
+ :param content: Full SKILL.md content for action="create" or action="update".
:param scope: "workspace" for .cptr/skills, or "global" for ~/.cptr/skills.
:param file_path: Relative bundle path for action="write_file".
:param file_content: File content for action="write_file".
"""
- from cptr.utils.skills import create_managed_skill, write_managed_skill_file
+ from cptr.utils.skills import (
+ create_managed_skill,
+ delete_managed_skill,
+ update_managed_skill,
+ write_managed_skill_file,
+ )
+ from cptr.models import Config
+
+ if (await Config.get("skills.enabled")) in (False, "false", "0"):
+ return json.dumps({"success": False, "error": "skills are disabled"}, ensure_ascii=False)
+ if (await Config.get("skills.tool_enabled")) in (False, "false", "0"):
+ return json.dumps(
+ {"success": False, "error": "skill management is disabled"},
+ ensure_ascii=False,
+ )
workspace = __context__.get("workspace", "")
try:
if action == "create":
result = create_managed_skill(workspace, name, content or "", scope)
+ elif action == "update":
+ result = update_managed_skill(workspace, name, content or "")
elif action == "write_file":
result = write_managed_skill_file(workspace, name, file_path or "", file_content)
+ elif action == "delete":
+ result = delete_managed_skill(workspace, name)
else:
result = {"success": False, "error": f"unsupported action '{action}'"}
except Exception as e:
@@ -2842,6 +2865,17 @@ async def get_tool_list(builtin_tools: dict | None = None) -> list[dict]:
memory_enabled = (await Config.get("memory.enabled")) not in (False, "false", "0")
if not memory_enabled:
tools.pop("update_memory", None)
+ skills_enabled = (await Config.get("skills.enabled")) not in (False, "false", "0")
+ skills_tool_enabled = (await Config.get("skills.tool_enabled")) not in (
+ False,
+ "false",
+ "0",
+ )
+ if not skills_enabled:
+ tools.pop("view_skill", None)
+ tools.pop("manage_skill", None)
+ elif not skills_tool_enabled:
+ tools.pop("manage_skill", None)
if (await Config.get("browser.enabled")) in (True, "true", "1"):
tools.update(BROWSER_TOOLS)
if (await Config.get("subagents.enabled")) in (True, "true", "1"):
diff --git a/dev.sh b/dev.sh
index b89b503..31da681 100755
--- a/dev.sh
+++ b/dev.sh
@@ -1,3 +1,3 @@
#!/bin/bash
export CPTR_DATA_DIR="${CPTR_DATA_DIR:-$(cd "$(dirname "$0")" && pwd)/.cptr}"
-uv run cptr run --reload --host 0.0.0.0 --port 9741
+uv run --extra all cptr run --reload --host 0.0.0.0 --port 9741
diff --git a/pyproject.toml b/pyproject.toml
index e6d91a2..bb2af1e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
[project]
name = "cptr"
-version = "0.8.1"
+version = "0.8.2"
description = "Your computer, from anywhere. Code, manage, and control your machine from the web."
license = {file = "LICENSE"}
readme = "README.md"
diff --git a/uv.lock b/uv.lock
index 55fa9e9..b1a10bf 100644
--- a/uv.lock
+++ b/uv.lock
@@ -284,7 +284,7 @@ wheels = [
[[package]]
name = "cptr"
-version = "0.8.1"
+version = "0.8.2"
source = { editable = "." }
dependencies = [
{ name = "aiosqlite" },