boboyr/TiecodePluginSkills

Desenvolvimento de Plugins Tiecode

Documentação voltada para o desenvolvimento de plugins para o Tiecode IDE / QiStudio (pacote do host: com.tiecode.develop). O nome oficial do Tiecode Studio é QiStudio (plataforma de engenharia aberta de nova geração, primeiro aplicativo móvel a implementar o padrão OSGi, estendendo o ambiente de desenvolvimento de projetos na forma de microcomponentes / plugins). Conteúdo originado de: engenharia reversa de studio-api-1.0-preview5.jar (com.rapid.api.*) + reconstituição do código-fonte de mais de uma dezena de plugins reais (Go, Scala, Kotlin, Linux, AAR, LibGDX, execução sem instalação, etc.).

---

Materiais Oficiais e Repositórios (Importante)

Repositório Oficial Gitee

Repositório	Descrição
MobileIPE-Plugin-DevManual	Tutorial oficial de desenvolvimento de plugins (microcomponentes QiStudio). Contém: QiStudio核心体系介绍.md, Rapid框架介绍.md, plugin/扩展点介绍.md, plugin/插件清单配置.md, plugin/注册你的微组件——插件.md
TiecodeCompiler-Public	Repositório de artefatos do compilador Tiecode (versão multiplataforma). Contém: docs/ (documentação de uso/gramática/empacotamento/integração de plataforma do compilador), headers/tiec/ (API C + headers de encapsulamento C++), prebuilt/ (cli + bibliotecas dinâmicas para android/windows/linux/ohos/wasm), stdlibs/ (bibliotecas básicas Android/CXX/Web)
QiStudio-PluginSamples	Conjunto oficial de exemplos de plugins QiStudio (19+ exemplos: injeção de dependência, efeitos de editor/parênteses coloridos, log em janela flutuante, gerenciador de projetos Html, requisições de rede, extensão de ícones, toolchain Javac9, realce de sintaxe, tema personalizado, ciclo de vida Application, componentes de projeto, diversos menus, páginas de ferramentas, páginas de configuração, etc.)

O nome do jar da API oficial é qistudio-api-<versão>.jar (o studio-api-1.0-preview5.jar descompilado neste skill é o SDK do lado do host). Grupo de comunicação QQ: 1016399857.

Implementações de Referência da Comunidade (GitHub)

Coleção de código-fonte de plugins reais associada a este skill (repositório único com múltiplos diretórios, contendo 8 plugins completos e compiláveis):

https://github.com/boboyr/tiecode-plugin

Diretório	Plugin	Capacidades Demonstradas
go语言工程插件/	Projeto de engenharia Go (console + SDL3)	Duplo template + autocompletar LSP(gopls) + realce TextMate + toolchain + configuração de execução + nós virtuais na árvore de arquivos
结绳安卓工程aar构建插件/	Construção AAR/JAR	Reutilização da toolchain do host + saída em chinês com NameGenerator
结绳免安装运行插件/	Executor sem instalação	Reutilização de tarefas do host + carregamento de APK não instalado via plugin
libgdx游戏编辑器插件/	Editor visual LibGDX	Designer + menu de área de código do editor + criação de cena
scala安卓工程插件/	Projeto de engenharia Scala Android	Cadeia de construção completa com sbt + template de projeto de plugin Tiecode + construção/depuração de plugin
结绳Linux工程插件/	Plugin Tiecode Linux-SDL3	Toolchain GCC + SDL3 + cadeia de tarefas
外部kotlin文件注解插件/	Anotação de arquivos Kotlin externos	API do compilador Tiecode: CompilerPlugin + AnnotationProcessor + autocompletar Kotlin
BasicLanguages-lang参考/	Linguagens básicas oficiais	Referência de realce de sintaxe para csml/json/markdown/xml/properties

---

0. Conceitos Centrais e Arquitetura Geral

O Tiecode é um host IDE modular, onde os plugins são distribuídos como arquivos .rmx. Um .rmx é essencialmente um APK: AndroidManifest.xml + classes.dex + META-INF/program.json. O host descobre as capacidades do plugin através dos pontos de extensão (extension points) declarados no program.json, e não pelos componentes do <application> ou pelos quatro componentes principais do AndroidManifest.

0.1 Três Pacotes Chave

Pacote	Função
com.rapid.api.*	SDK do plugin (corpo desta documentação). Projeto, linguagem, tarefa, estrutura, página, UI, rede, etc.
com.rapid.framework.*	Camada de framework: VFS (Sistema de Arquivos Virtual), Chaves de Serviço/Dado/Evento, contêiner program/plugin
com.tiecode.compiler.*	Compilador Tiecode (árvore sintática / tabela de símbolos / completer/processor da toolchain) — lado do host, plugins geralmente usam apenas seu subpacote toolchain

0.2 Pontos de Extensão (array extension do program.json)

Estrutura completa do META-INF/program.json:

{
  "id": "com.goproject.plugin",
  "name": "go语言工程插件",
  "engine": "plugin",
  "description": "...",
  "versionCode": 4,
  "versionName": "1.3",
  "minSupport": 1,
  "vendor": { "name": "boboyr", "email": "", "url": "#" },
  "extension": [
    { "point": "application", "class": "com.goproject.plugin.MyApplication" },
    { "point": "project.manager", "class": "com.goproject.plugin.project.GoProjectManager" },
    { "point": "project.language", "class": "com.goproject.plugin.lang.GoLanguageFactory",
      "scope": { "unit": "project", "identifiers": "sample.go" } },
    { "point": "domain.menu", "class": "com.goproject.plugin.Gomodmenu" }
  ]
}

Explicação do campo minSupport (versão mínima suportada do host)

minSupport é um inteiro que indica a versão mínima do Tiecode que o plugin requer. Diferentes versões têm valores diferentes:

Versão do Tiecode	minSupport	Descrição
Tiecode 4.6	1	Plugin para 4.6 escreve "minSupport": 1
Tiecode 4.7	2	Plugin para 4.7 escreve "minSupport": 2

Ou seja: ao desenvolver um plugin para o 4.6, preencha minSupport com 1; ao atualizar para 4.7 (ou criar um plugin direcionado ao 4.7), preencha com 2. A regra específica de vinculação do valor com o número da versão do host deve ser consultada na documentação oficial; durante o desenvolvimento, basta preencher de acordo com a versão alvo.

Conjunto completo de pontos de extensão confirmados (campo point):

Ponto de Extensão	Classe a implementar/herdar	Função	Plugin de Origem
application	AndroidPlugin	Entrada do plugin, onInit/activate/onUninstall	go/scala/aar/sem instalação
project.manager	ProjectManager (usualmente CodeProjectManager)	Registrar um tipo de projeto	go/scala/linux
project.language	LanguageFactory	Registrar linguagem (realce + extensões de arquivo associadas), pode ter scope	go/scala
project.language.engine	LanguageEngine	Registrar mecanismo de linguagem (contêiner para providers de autocompletar/diagnóstico, etc.)	Plugin de console Tiecode
project.toolchain	Subclasse de Tool (ex: SunJdk8Compiler)	Registrar toolchain de compilação	JavaCompiler8
project.component	ComponentIntegrator/ComponentFactory	Anexar componentes ao abrir o projeto (configuração de execução/popup inicial/hook)	linux/kotlin/aar/sem instalação
project.file.creationOption	PSObjectCreationOption	Item de menu "Novo Arquivo" na árvore de arquivos	kotlin/libgdx
project.file.openWithEditor	PSObjectOpeningOption	"Abrir com" para arquivos	kotlin
project.event.fileUi	ProjectFileUiEvent	Evento de UI da árvore de arquivos (definir ícone, etc.)	kotlin
domain.menu	BaseDomainMenuAction/ação de menu	Item de menu de nível superior	go
domain.menu.editor.code	Menu da área de código do editor	libgdx
platform.settingsBuilder	SettingsBuilder	Adicionar subpágina na página de configurações	scala Android
project.file.creationOption	—	—	—

Nota: scope.identifiers é usado para restringir uma linguagem/componente a um determinado typeId de projeto (ex: sample.go). Para certos pontos de extensão, class pode ser None (placeholder).

---

1. Entrada do Plugin: Ponto de Extensão application

import com.rapid.framework.program.android.app.AndroidPlugin;
import com.rapid.framework.program.android.DvmPluginDescriptor;
import com.rapid.api.Platform;
import com.rapid.api.framework.project.toolchain.ToolchainService;
import com.rapid.api.framework.project.ProjectServiceKeys;

public class MyApplication extends AndroidPlugin {
    @Override
    public void onInit(DvmPluginDescriptor descriptor) {
        // Registrar toolchain de compilação personalizada (exemplo: compilador Go)
        ToolchainService service = Platform.getService(ProjectServiceKeys.TOOLCHAIN);
        service.setTool(GoCompileApiKeys.Gocompile, new BaseGoCompiler());
    }
    @Override
    public void activate() {
        // Executado uma vez quando o plugin é ativado (geralmente colocar hooks, listeners, montagem de plugin de compilação)
    }
    @Override
    public void onUninstall() {
        // Limpeza na desinstalação: encerrar processos filhos iniciados (ex: gopls), desconectar LSP
    }
}

API chave (com.rapid.api.Platform) :

• Platform.getService(Key<T>) — Obter serviço do host (ex: ProjectServiceKeys.TOOLCHAIN)
• Platform.getProject() — Objeto do projeto atualmente aberto
• Platform.getApplicationContext() — Context do host

---

2. Tipo de Projeto: Ponto de Extensão project.manager

Um plugin registra um "tipo de projeto" (ex: go语言工程, 结绳安卓工程) através de ProjectManager.

2.1 Esqueleto do Gerenciador

public class GoProjectManager extends CodeProjectManager<GoProject> {
    public final static String TYPE = "go语言工程";       // Nome de exibição
    public final static String IDENTIFIER = "sample.go"; // typeId, armazenado em project.json

    public GoProjectManager() {
        super();
        this.fileManager = new GoFileManager();   // Opcional: gerenciador de arquivos personalizado (definir ícone, etc.)

        // ① Modos de abertura de arquivo (por extensão)
        fileManager.addPSObjectOpeningOption(DefaultOpeningOption.INSTANCE, ".go", ".mod");
        // ② Modos de expansão de nó na árvore de arquivos (nó virtual "Bibliotecas Externas")
        fileManager.addPSObjectExpansionCase(new ExternalLibrariesExpansionCase(), MARKER);
        // ③ Item de menu "Novo Arquivo"
        fileManager.addPSObjectCreationOption(new GoFileCreationOption());
        // ④ Mecanismo de linguagem e fábrica de linguagem
        languageManager.registerEngine("go", GoLanguageEngine.getInstance());
        languageManager.registerLanguageFactory(new GoLanguageFactory());
        languageManager.registerOperatorProvider(GoLanguage.ID, new GoOperatorProvider());
        // ⑤ Templates de criação de projeto
        addTemplate(new GoConsoleTemplate());
        addTemplate(new GoSdl3Template());
    }

    @Override public String getIdentifier() { return IDENTIFIER; }

    @Override public TypeDescription getTypeDescription() {
        Drawable d = ContextUtils.getDrawable(AndroidPlugins.getContext(this), R.drawable.golang);
        return new TypeDescription(TYPE, TypeDescription.APPLICATION, d);
    }

    @Override public GoProject newProject() { return new GoProject(); }

    @Override public boolean isProjectDir(File file) { return false; }
}

Métodos da interface ProjectManager (do javap):

String getIdentifier();
TypeDescription getTypeDescription();      // Nome + tipo + ícone
List<Template<T>> getTemplates();
void addTemplate(Template<T>);
ProjectFileManager<T> getFileManager();
T newProject();
void load(T, LoadingPresentation);
boolean isProjectDir(File);                // Determinar se um diretório é um projeto deste tipo
String backup(T); void delete(T);

Constantes de tipo de TypeDescription: APPLICATION / CONSOLE / LIBRARY.

---

3. Objeto de Projeto e Montagem do Pipeline: CodeProject.prepare()

Cada tipo de projeto corresponde a uma subclasse de Project. prepare() é chamado pelo host ao abrir o projeto; neste momento, os arquivos de template já foram escritos, e é possível montar a cadeia de tarefas, configurações de execução e componentes com base no conteúdo do diretório.

public class GoProject extends CodeProject {
    @Override
    public void prepare() {
        if (GoProjectKind.isSdl3(getProjectDir())) {
            Task buildLibmain = new BuildLibmainTask();
            Task publishLib = new PublishLibTask();
            addTask(buildLibmain);
            addTask(publishLib);
            publishLib.dependsOn(buildLibmain);      // Dependência de tarefa
            addRunConfiguration(new GoSdl3RunConfiguration());
        } else {
            addTask(new CompilerGoTask());
            addTask(new RunGoTask());
            addRunConfiguration(new GoStartRunConfig());
            addRunConfiguration(new ElfRunConfig());
        }
    }
    @Override public ProjectVariant getVariant() { return ProjectVariant.DEBUG; }
}

Métodos chave de CodeProject (extends BaseProject):

void prepare();
TaskContainer getTasks();  TaskExecutor getTaskExecutor();
void addTask(Task);  void setTasks(Iterable<Task>);
void addRunConfiguration(RunConfiguration);   // Exclusivo de CodeProject
ProjectVariant getVariant();  void setVariant(ProjectVariant);
Logger getLogger();  void setLogger(Logger);
String getName();
File getProjectDir();  File getChildFile(String);   // Resolver caminho relativo do projeto para File
void recycle();

Valores de ProjectVariant: DEBUG / RELEASE / UNDEFINED.

Dica (do plugin Go): em prepare(), escrever arquivos de marcação (ex: External Libraries) no projeto pode adicionar capacidades a projetos antigos existentes de uma só vez, sem necessidade de recriar o projeto.

---

4. Template de Projeto: BaseTemplate

O template determina quais opções aparecem na caixa de diálogo "Novo Projeto" e quais arquivos são escritos durante a criação.

public class GoConsoleTemplate extends BaseTemplate<GoProject> {
    @Override public String getName() { return "控制台工程"; }
    @Override public Drawable getPicture() { return null; }        // Imagem de pré-visualização do template, pode ser null
    @Override public String getDefaultProjectName() { return "我的go控制台工程"; }
    @Override public Form getForm() { return new Form(); }         // Pode adicionar campos de entrada

    @Override public void create(GoProject project, Form form,
                                 Project.OnProjectCreateListener listener) {
        try {
            File file = project.getChildFile("src/main.go");
            String html = AssetUtils.readAsset(AndroidPlugins.getContext(this), "sample/main.go");
            html = html.replace("${project_name}", project.getName());
            FileUtils.writeFile(html, file);                        // Escrever no diretório do projeto
            FileUtils.writeFile("module main\ngo 1.26.0", project.getChildFile("src/go.mod"));
            listener.onSuccess();                                    // Callback de sucesso
        } catch (IOException e) {
            listener.onFail("写出默认文件失败");                      // Callback de falha
        }
    }
}

Métodos da interface Template<T>:

String getName();
Drawable getPicture();
String getDefaultProjectName();
Form getForm();          // com.rapid.framework.data.form.Form, pode addInput(new FormInput(...))
void create(T, Form, OnProjectCreateListener);   // OnProjectCreateListener.onSuccess()/onFail(msg)

Recursos do template: Coloque os arquivos de template em app/src/main/assets/<nome> e use AssetUtils.readAsset / AssetUtils.unZipAssetsFolder(context, zipName, destDir) para ler e descompactar. (O template do projeto SDL3 usa gosdl3_template.zip em asset/ e descompacta todo o conteúdo no diretório do projeto.)

---

5. Tarefa de Compilação e Toolchain: BaseTask + ToolchainService

5.1 Tarefa BaseTask

public class CompilerGoTask extends BaseTask {
    @Override public void execute() throws TaskInterruptError {
        File output = new File(Platform.getProject().getProjectDir() + "/output");
        if (!output.exists()) output.mkdirs();
        GoCompile a = Platform.getService(ProjectServiceKeys.TOOLCHAIN)
                             .getTool(GoCompileApiKeys.Gocompile);
        if (!a.isInstalled(ctx)) { logger.info("安装工具链..."); a.install(ctx); }
        GoCompileParams p = new GoCompileParams();
        p.inputFiles = FileUtils.getGofile(srcDir);
        p.outputPath = output.getPath();
        p.options = new String[]{"build", "-o"};
        a.compile(p, new CompileOnExecutionCallback());
    }

    // Deve sobrescrever: o padrão BaseTask.prepare lança UnsupportedOperationException;
    // e os campos logger/variant devem ser atribuídos aqui, caso contrário, logger.info em execute() causará NPE.
    @Override public void prepare(Project project, ProjectVariant variant, Logger logger) {
        this.logger = logger;
        this.variant = variant;
        Os.setenv("GOROOT", goRoot, false);   // Definir variável de ambiente (android.system.Os)
    }

    @Override public String getId() { return "compileWithGo"; }   // Referenciado por getTaskId() na configuração de execução
    @Override public String getName() { return "编译到目标平台"; }
}

Interface Task (do javap):

String getId();  String getName();
void prepare(Project, ProjectVariant, Logger);      // Nota: padrão lança exceção, deve sobrescrever
void execute() throws TaskInterruptError;
TaskState getState();
void interrupt();
void dependsOn(Task...);  void dependsOn(List<Task>);
Task getDependencyTask(String);  Task getDependencyTaskByName(String);
String getIntermediatePath();  String getIntermediatePath(String);
String getOutputPath();  String getOutputPath(String);
File getGeneratedDir();

Ponto de atenção (comentário original no plugin Go): Se logger não for atribuído na tarefa, usar logger.info em execute() causará NPE e falha imediata, impedindo a execução da instalação da toolchain.

5.2 Toolchain Tool + Installable

public interface Tool { /* Possui chaves embutidas como ANDROID_SDK/AAPT/AAPT2/D8/R8/DX/PROGUARD/
                         MANIFEST_MERGER/APK_SIGNER/JAVA_SDK/JAVA_COMPILER, etc. */ }
public interface Installable {
    boolean isInstalled(Context);
    void install(Context) throws IOException;
}

• Toolchains personalizadas são registradas em application.onInit() usando ToolchainService.setTool(customKey, impl).
• As chaves de toolchain Android embutidas estão na interface Tool (podem ser usadas diretamente com Platform.getService(TOOLCHAIN).getTool(Tool.AAPT2)).
• Reutilizar a toolchain do host (prática dos plugins AAR / sem instalação): não empacotar o próprio compilador, mas usar getDependencyTaskByName("compileWithTiecodec") para obter a tarefa do host e anexar dependências, ou reutilizar diretamente getTaskId().

---

6. Configuração de Execução: RunConfiguration / TaskRunConfiguration

Adiciona itens executáveis ao menu "Executar" do projeto. O mais comum é TaskRunConfiguration: especifica um id de tarefa, e após a execução bem-sucedida, chama o callback onResult.

public class GoStartRunConfig extends TaskRunConfiguration {
    public Project getProject() { return Platform.getProject(); }
    public String getTaskId() { return "RunWithGo"; }          // Id da tarefa associada
    public ProjectVariant getVariant() { return ProjectVariant.DEBUG; }
    @Override public String getName() { return "Executar Projeto Go"; }
    @Override public void onResult(Task.Result result) {
        // Lógica após execução da tarefa
    }
}

Métodos de RunConfiguration:

String getName();  Project getProject();  ProjectVariant getVariant();  void setTaskProvider(TaskProvider);
void start();  void stop();  boolean isRunning();  void addRunningListener(Runnable);

---

7. Árvore de Arquivos e PSObject (Sistema de Arquivos Virtual)

O QiStudio representa arquivos e diretórios com PSObject. O plugin pode personalizar:

• CreationOption – novos itens no menu "Novo" da árvore
• OpeningOption – modos de abertura de arquivo (clique duplo)
• ExpansionCase – nós virtuais na árvore (ex: "Bibliotecas Externas", "SDK")

7.1 Nós Virtuais (PSObjectExpansionCase)

public class ExternalLibrariesExpansionCase implements PSObjectExpansionCase {
    public static final Object MARKER = new Object();
    @Override public boolean isSpecialFolder(File folder) { return false; }
    @Override public Object getChildren(PSObjectFile file, Object parentValue) {
        if (MARKER.equals(parentValue)) {
            // Retornar lista de nós filhos virtuais
            return new VirtualNode("GOPATH", file);
        }
        return null;
    }
    @Override public Object getParentValue(PSObjectFile file, Object parentValue) { return null; }
}

PSObjectExpansionCase interface:

boolean isSpecialFolder(File);
Object getChildren(PSObjectFile, Object parentValue);
Object getParentValue(PSObjectFile, Object parentValue);
boolean isLeaf(PSObjectFile, Object value);

7.2 Abrir com (OpeningOption)

// No construtor de GoProjectManager:
fileManager.addPSObjectOpeningOption(DefaultOpeningOption.INSTANCE, ".go", ".mod");

PSObjectOpeningOption interface:

boolean isAvailable(PSObjectFile, Object value);
void open(PSObjectFile, Object value);

7.3 Injeção de Menu de Contexto na Árvore

No project.event.fileUi:

fileManager.addPSObjectOpeningOption(new DecompileKtFileOpeningOption(), ".kt");

---

8. Linguagem, Realce e Autocompletar: LanguageFactory + LanguageEngine + TextMate + LSP

8.1 LanguageFactory:

public class GoLanguageFactory extends BaseLanguageFactory {
    private static final GoLanguageFactory INSTANCE = new GoLanguageFactory();
    @Override public Language getLanguage() { return GoLanguage.INSTANCE; }

    static class GoLanguage extends BaseLanguage {
        static final Language INSTANCE = new GoLanguage();
        @Override public String getId() { return "go"; }
        @Override public CharSequence getDisplayName() { return "Go"; }
        @Override public String[] getFileTypes() { return new String[]{".go"}; }
    }
}

BaseLanguageFactory methods:

Language getLanguage();  String getId();

8.2 LanguageEngine:

Registra providers de autocompletar, diagnóstico e operador.

public class GoLanguageEngine extends BaseLanguageEngine {
    @Override public String getId() { return "go"; }
    @Override public void init() { /* Registrar providers */ }
}

Providers podem ser registrados em init(): addCompletionProvider, addDiagnosisProvider, addOperatorProvider.

8.3 Autocompletar via TextMate:

Use arquivos .JSON-tmbundle e .tmLanguage para obter realce de sintaxe básico baseado em expressões regulares e autocompletar por snippets.

8.4 Autocompletar via LSP (IDE Moderno):

// No plugin Go, o LanguageEngine inicia o processo gopls e encapsula as requisições LSP.
// Implementar provedores de conclusão que chamam textDocument/completion via soquete ou stdin/stdout.

---

9. Compilador Tiecode: CompilerPlugin + AnnotationProcessor (para plugins de compilador)

O pacote com.tiecode.compiler.* fornece a API do compilador Tiecode, permitindo que plugins interceptem a compilação.

9.1 Interface CompilerPlugin:

public interface CompilerPlugin {
    void process(CompilerContext context);  // Gancho de processamento durante a compilação
}

CompilerContext methods:

CompilationUnit getUnit();  // Unidade de compilação atual
SymbolTable getSymbols();   // Tabela de símbolos
void reportDiagnostic(Diagnostic); // Relatar diagnóstico

9.2 Interface AnnotationProcessor:

public interface AnnotationProcessor {
    void process(AnnotationMirror mirror, Element element);
}

---

10. UI, Menu e Páginas de Configuração

10.1 domain.menu – Menu de Nível Superior

public class Gomodmenu extends BaseDomainMenuAction {
    @Override public boolean onAction(View view) {
        // Lógica ao clicar no menu
        return true;
    }
}

BaseDomainMenuAction:

boolean onAction(View);

10.2 platform.settingsBuilder – Página de Configurações

public class ScalaSettingsBuilder implements SettingsBuilder {
    @Override
    public void build(Settings settings) {
        settings.add(new CategorySettings("Scala"));
        settings.add(new StringSetting("scala.home", "Diretório Scala"));
    }
}

---

11. Publicação e Empacotamento do Plugin

O plugin é empacotado como .rmx (APK). As etapas são aproximadamente:

1. Estrutura do projeto: app/src/main/java/, app/src/main/assets/, app/src/main/META-INF/program.json
2. Compilar para DEX e combinar com AndroidManifest.xml
3. Assinar o APK com keystore".rmx` é apenas uma extensão de arquivo, o formato é APK padrão.

---

12. Roteiro de Depuração e Próximos Passos

• Use Platform.getService(ProjectServiceKeys.TOOLCHAIN) para obter toolchains do host
• Use Platform.getProject().getChildFile("caminho/relativo") para obter arquivos do projeto
• Ponto de entrada: sempre sobrescreva onInit em AndroidPlugin
• Veja os exemplos reais: https://github.com/boboyr/tiecode-plugin (8 plugins completos)
• Depuração: Log.d e Platform.getLogger().info() para depuração

---

Apêndice: Extensões Conhecidas e Referência Rápida de Classes

Tópico	Classe Chave	Arquivo de Documentação Relacionado
Projeto	CodeProjectManager, CodeProject	project.manager em program.json
Tarefa	BaseTask, TaskContainer	TaskRunConfiguration
Toolchain	Tool, Installable, ToolchainService	project.toolchain em program.json
Árvore de Arquivos	PSObjectCreationOption, PSObjectOpeningOption, PSObjectExpansionCase	Interface ProjectFileManager
Linguagem	BaseLanguageFactory, LanguageEngine, Language, OperatorProvider	project.language, project.language.engine
Autocompletar	CompletionProvider, TextMateCompletionProvider	LanguageEngine.init()
Compilador	CompilerPlugin, AnnotationProcessor	com.tiecode.compiler.* javadoc
UI	BaseDomainMenuAction, SettingsBuilder, ComponentIntegrator	domain.menu, platform.settingsBuilder