@tasksai/install 0.1.38 → 0.1.40

package/runtime/workflows/released_catalog.py

@@ -0,0 +1,91 @@
+"""Source-bound intake for the 175 released Realtor skills.
+
+The installed registry contains public identifiers and hashes only. Licensed
+content must already have been delivered by the existing execute operation.
+This module neither fetches content nor consumes a credit.
+"""
+from hashlib import sha256
+import json
+from pathlib import Path
+import re
+from .store import JobError
+
+REGISTRY = Path(__file__).with_name('realtor-release-registry.json')
+
+
+def registry():
+    data = json.loads(REGISTRY.read_text(encoding="utf-8"))
+    if data.get('product_id') != 'realtor' or len(data.get('skills', {})) != 175:
+        raise JobError('Realtor workflow registry is invalid')
+    return data['skills']
+
+
+def release_matches(skill_id, version, content_hash):
+    entry=registry().get(skill_id)
+    if not entry: return False
+    return any(r.get('version')==version and r.get('content_sha256')==content_hash
+               for r in [entry]+entry.get('history',[]))
+
+
+def explicit_requirement(group, instruction):
+    """Use explicit intake labels only; never infer necessity from subject words."""
+    heading=re.sub(r'[*#:]', '', group).strip().casefold()
+    if re.match(r'^conditionally required(?: inputs| information)?$',heading):return 'conditional'
+    if re.match(r'^optional(?: inputs| information)?$',heading):return 'optional'
+    if re.match(r'^required(?: inputs| information)?$',heading):return 'required'
+    if re.search(r'\(optional\)(?:\s*:|\s*$)',instruction,re.I):return 'optional'
+    return 'evaluate_in_context'
+
+
+def bind(skill_id, version, content):
+    content_hash=sha256(content.encode()).hexdigest() if isinstance(content,str) else None
+    if not release_matches(skill_id,version,content_hash):
+        raise JobError('This released skill needs a matching workspace conversion')
+    headings = list(re.finditer(r'^## (.+)$', content, re.M))
+    sections = {match.group(1): content[match.end():headings[i+1].start() if i+1<len(headings) else len(content)].strip()
+                for i,match in enumerate(headings)}
+    required = ('Input Format', 'Output Format', 'Source and Assumption Rules', 'Instructions', 'Quality Checks', 'Compliance and Escalation')
+    if any(not sections.get(key) for key in required):
+        raise JobError('Released skill is missing a workspace instruction section')
+    # Keep section labels verbatim: many carry important conditional scope.
+    # An input's necessity is decided by the full skill for this user request,
+    # not by absence of the word "optional" in a single list item.
+    fields = []
+    standalone = []
+    group = ''
+    for line in sections['Input Format'].splitlines():
+        if re.match(r'^#{3,6}\s+', line):
+            group = re.sub(r'^#{3,6}\s+', '', line)
+        elif re.match(r'^\*\*[^*]+\*\*', line):
+            if re.match(r'^\*\*[^*]+\*\*\s*(?:\([^)]*\))?\s*:\s*\S', line):
+                standalone.append((line, group))
+            else:
+                group = line
+        elif re.match(r'^\s*(?:[-*]|\d+[.)])\s+', line):
+            text = re.sub(r'^\s*(?:[-*]|\d+[.)])\s+', '', line)
+            fields.append({'key': 'input_'+str(len(fields)+1), 'instruction': text,
+                           'group': group, 'requirement': explicit_requirement(group, text)})
+    # Append newly recognized unbulleted requests so existing saved input_N
+    # answers retain their original meaning. A sole prose request already used
+    # the whole-section fallback; preserve that established field below.
+    if fields:
+        for text, parent in standalone:
+            fields.append({'key':'input_'+str(len(fields)+1), 'instruction':text,
+                           'group':parent, 'requirement':explicit_requirement(parent,text)})
+    no_input = bool(re.fullmatch(r'No (?:user )?inputs? (?:is |are )?required[.!]?', sections['Input Format'], re.I))
+    if not fields and not no_input:
+        fields = [{'key':'input_1','instruction':sections['Input Format'], 'group':'', 'requirement':'evaluate_in_context'}]
+    return {'skill_id':skill_id, 'version':version, 'content_sha256':content_hash,
+            'instructions':content, 'input_instructions':sections['Input Format'],
+            'output_instructions':sections['Output Format'], 'fields':fields,
+            'output_policy': {'word':True, 'excel':'requires_deliverable_mapping'},
+            'readiness_policy':'full_skill_context_required'}
+
+
+def intake(binding, answers):
+    fields = binding['fields']; keys={field['key'] for field in fields}
+    if not isinstance(answers,dict) or set(answers)-keys or any(not isinstance(v,str) or len(v)>10000 for v in answers.values()):
+        raise JobError('Answers must match the selected skill and stay within the input limit')
+    supplied={key:answers.get(key,'').strip() for key in keys}
+    return {'answers':supplied, 'unanswered':[field['key'] for field in fields if not supplied[field['key']]],
+            'needs_context_check':True}

package/runtime/workflows/source_capture.py

@@ -0,0 +1,82 @@
+"""Capture a selected guide's public source as local evidence, never as approval."""
+from datetime import datetime,timezone
+from hashlib import sha256
+from html.parser import HTMLParser
+import json
+import os
+from pathlib import Path
+import re
+import uuid
+from .public_source_fetch import fetch
+from .documents import Documents
+from .store import JobError,canonical,file_hash
+
+class PageText(HTMLParser):
+    def __init__(self):super().__init__(convert_charrefs=True);self.hidden=0;self.parts=[]
+    def handle_starttag(self,tag,attrs):
+        if tag in ('script','style','head','svg'):self.hidden+=1
+        if not self.hidden and tag in ('p','div','br','li','h1','h2','h3','h4','tr','section'):self.parts.append('\n')
+    def handle_endtag(self,tag):
+        if tag in ('script','style','head','svg') and self.hidden:self.hidden-=1
+        if not self.hidden and tag in ('p','div','li','h1','h2','h3','h4','tr','section'):self.parts.append('\n')
+    def handle_data(self,data):
+        if not self.hidden:self.parts.append(data)
+
+
+def capture(workspace,job_id,guide_id,index):
+    view=workspace.view(job_id);guide=view['authority_guide']
+    if not guide or guide['id']!=guide_id or guide['refresh_needed']:raise JobError('Select a current source guide first')
+    sources=guide['packet']['sources']
+    if isinstance(index,bool) or not isinstance(index,int) or not 0<=index<len(sources):raise JobError('Choose a source from the selected guide')
+    source=sources[index];response=fetch(source.get('url'))
+    raw=response['body'];raw_hash=sha256(raw).hexdigest()
+    identity=sha256(canonical([guide_id,response['requested_url'],response['final_url'],raw_hash]).encode()).hexdigest()
+    root=workspace.store._safe(workspace.store.root/job_id/'source-captures');root.mkdir(exist_ok=True,parents=True,mode=0o700)
+    target=workspace.store._safe(root/identity)
+    if not target.exists():
+        staging=workspace.store._safe(root/('attempt-'+uuid.uuid4().hex));staging.mkdir(mode=0o700)
+        metadata={k:response[k] for k in ('requested_url','final_url','content_type')}
+        metadata.update(capture_id=identity,guide_id=guide_id,retrieved_at=datetime.now(timezone.utc).isoformat(),body_sha256=raw_hash,verification='retrieved_not_professionally_verified')
+        (staging/'original.bin').write_bytes(raw)
+        if response['content_type']=='application/pdf':body=raw;extension='.pdf'
+        else:
+            try:text=raw.decode('utf-8-sig')
+            except UnicodeDecodeError:raise JobError('Source text encoding is unsupported; add an accessible source document instead')
+            if response['content_type']=='text/html':
+                parser=PageText();parser.feed(text);text='\n'.join(line.strip() for line in ''.join(parser.parts).splitlines() if line.strip())
+            if not text.strip():raise JobError('No readable source text found; add an accessible document')
+            body=('Captured public source\nURL: '+response['final_url']+'\nRetrieved at (not the source or effective date): '+metadata['retrieved_at']+'\nRetrieval is not professional verification.\n\n'+text).encode('utf-8');extension='.txt'
+        filename=(re.sub(r'[^A-Za-z0-9 _-]','',source.get('title') or 'Authority source').strip()[:70] or 'Authority source')+extension
+        (staging/filename).write_bytes(body);metadata['document_filename']=filename;metadata['document_sha256']=sha256(body).hexdigest()
+        (staging/'capture.json').write_bytes((canonical(metadata)+'\n').encode('utf-8'))
+        for path in staging.iterdir():
+            path.chmod(0o600)
+            with path.open('r+b') as stream:os.fsync(stream.fileno())
+        with workspace.store._db() as db:
+            db.execute('BEGIN IMMEDIATE');workspace.store._job(db,job_id)
+            if not target.exists():staging.rename(target)
+    metadata=json.loads(workspace.store._safe(target/'capture.json').read_text(encoding='utf-8'))
+    if metadata.get('capture_id')!=identity or metadata.get('guide_id')!=guide_id or metadata.get('requested_url')!=response['requested_url'] or metadata.get('final_url')!=response['final_url']:
+        raise JobError('Captured source identity changed; restore the saved evidence before using it')
+    if Path(metadata['document_filename']).name!=metadata['document_filename'] or '\\' in metadata['document_filename']:raise JobError('Invalid captured source filename')
+    if metadata['body_sha256']!=raw_hash or file_hash(workspace.store._safe(target/'original.bin'))!=raw_hash or file_hash(workspace.store._safe(target/metadata['document_filename']))!=metadata['document_sha256']:
+        raise JobError('Captured source changed; restore the saved evidence before using it')
+    receipt=Documents(workspace.store,target,allow_customer_documents=True).import_document(job_id,metadata['document_filename'],'source-'+identity,False)
+    with workspace.store._db() as db:
+        db.execute('CREATE TABLE IF NOT EXISTS source_captures (job_id TEXT,document_id TEXT,capture_id TEXT,metadata TEXT,PRIMARY KEY(job_id,capture_id))')
+        previous=db.execute('SELECT metadata FROM source_captures WHERE job_id=? AND capture_id=?',(job_id,identity)).fetchone()
+        if previous and previous['metadata']!=canonical(metadata):raise JobError('Captured source metadata changed; restore the saved evidence before using it')
+        db.execute('INSERT OR IGNORE INTO source_captures VALUES (?,?,?,?)',(job_id,receipt['document_id'],identity,canonical(metadata)))
+    return {**receipt,'capture':metadata}
+
+
+def provenance(workspace,job_id,document_id):
+    with workspace.store._db() as db:
+        workspace.store._job(db,job_id)
+        if not db.execute("SELECT 1 FROM sqlite_master WHERE type='table' AND name='source_captures'").fetchone():return []
+        records=[json.loads(row['metadata']) for row in db.execute('SELECT metadata FROM source_captures WHERE job_id=? AND document_id=?',(job_id,document_id))]
+    for record in records:
+        folder=workspace.store._safe(workspace.store.root/job_id/'source-captures'/record['capture_id'])
+        if json.loads(workspace.store._safe(folder/'capture.json').read_text(encoding='utf-8'))!=record or file_hash(workspace.store._safe(folder/'original.bin'))!=record['body_sha256']:
+            raise JobError('Captured source evidence changed; restore it before generating')
+    return records